/* This machine-generated file includes source code from GNU Jitter.

   Copyright (C) 2016-2021 Luca Saiu
   Written by Luca Saiu

   GNU Jitter is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published
   by the Free Software Foundation, either version 3 of the License,
   or (at your option) any later version.

   GNU Jitter is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with GNU Jitter.  If not, see <https://www.gnu.org/licenses/>.


  Copyright (C) 2017, 2018, 2020, 2021  Luca Saiu
  Written by Luca Saiu

  This file is part of JitterLisp, distributed as an example along with
  GNU Jitter under the same license.

  JitterLisp is free software: you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation, either version 3 of the License, or
  (at your option) any later version.

  JitterLisp is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with JitterLisp.  If not, see <https://www.gnu.org/licenses/>.

*/

/* User-specified code, initial vm2 part: beginning. */

/* User-specified code, initial vm2 part: end */

/* These two macros are convenient for making VM-specific identifiers
   using VM-independent macros from a public header, without polluting
   the global namespace. */
#define JITTER_VM_PREFIX_LOWER_CASE jitterlispvm
#define JITTER_VM_PREFIX_UPPER_CASE JITTERLISPVM

#include <jitter/jitter-early-header.h>

//#include <config.h>

#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>

/* Early C code from the user. */

#   include <stdio.h>
  
  /* End of the early C code from the user. */

#include <jitter/jitter.h>
#include <jitter/jitter-instruction.h>

#define JITTER_THIS_CAN_INCLUDE_JITTER_EXECUTOR_H
#include <jitter/jitter-executor.h>

#ifdef JITTER_ENABLE_ASSEMBLY
#include <jitter/jitter-machine-common.h>
#include <jitter/machine/jitter-machine.h>
#endif // #ifdef JITTER_ENABLE_ASSEMBLY
#include <jitter/jitter-fatal.h>
#include <jitter/jitter-malloc.h>

#include "jitterlispvm-vm.h"
//#include "jitterlispvm-meta-instructions.h"
//#include "jitterlispvm-specialized-instructions.h"
//#include "jitterlispvm-state.h"

/* Include stack data structure support. */
#include <jitter/jitter-stack.h>

/* Include patch-in definitions, only if patch-in is enabled.  We know whether it is
   by checking JITTER_HAVE_PATCH_IN , defined in jitter/jitter-patch-in.h .
   The same for defects. */
#include <jitter/jitter-patch-in.h>
#include <jitter/jitter-fast-branch.h>
#include <jitter/jitter-defect.h>
#ifdef JITTER_HAVE_PATCH_IN
  JITTER_PATCH_IN_DESCRIPTOR_DECLARATIONS_(jitterlispvm);
#endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_HAVE_DEFECT_REPLACEMENT
  static void jitter_useless_function (void) asm ("jitter_fake_target_asm");
  static void jitter_useless_function (void) {}
  JITTER_DEFECT_DESCRIPTOR_DECLARATIONS_(jitterlispvm);
  static const char * const jitterlispvm_fake_target_asm
    = (const char *) & jitter_useless_function;
#endif // #ifdef JITTER_HAVE_DEFECT_REPLACEMENT

/* Always include the non-user fast-branch definitions, which use patch-ins where possible
   or consist in fallback definitions otherwise. */
#include <jitter/jitter-fast-branch.h>

#define JITTER_FAST_BRANCH_PREFIX jitterlispvm_

/* Most of the needed macros are in jitter-executor.h .  This however
   needs to be here, as it relies on a prefix to be substituted. */
#define _JITTER_STATE_BACKING  \
  (jitter_original_state->jitterlispvm_state_backing)
/* Expand to an l-value evaluating to the pending_notification field for
   the current state. */
#define JITTER_PENDING_NOTIFICATIONS  \
  (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA->pending_notifications)
/* Expand to an l-value evaluating to the pending field of the struct
   jitter_signal_notification element for the given signal, for the
   current state. */
#define JITTER_PENDING_SIGNAL_NOTIFICATION(signal_id)  \
  ((JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA->pending_signal_notifications + (signal_id))->pending)

/* Expand to the i-th fast register as an lvalue.  This is used internally,
   always with a literal index . */
#define JITTER_FAST_REGISTER(class, index)                             \
  (JITTER_CONCATENATE_FOUR(jitter_state_runtime.jitter_fast_register_, \
                           class, _, index))

/* Expand to a slow register lvalue, given an offset in bytes from the base. */
#define JITTER_SLOW_REGISTER_FROM_OFFSET(c, offset)               \
  (* ((JITTER_CONCATENATE_TWO(jitterlispvm_register_, c) * restrict)  \
      (((char *) jitter_array_base) + offset)))

/* Expand to the i-th register, which must be a slow register, as an lvalue.
   The given index must be a register index counting from 0 and including fast
   regusters as well, if there are any.  For example if an r class had 3 fast
   registers then the first slow register would be %r3, to be accessed as
   JITTER_SLOW_REGISTER(r, 3).  It would be invalid to access %r0, %r1 and
   %r2 which this macro, as %r0, %r1 and %r2 would be fast. */
#define JITTER_SLOW_REGISTER(c, i)                                          \
  JITTER_SLOW_REGISTER_FROM_OFFSET(c, JITTERLISPVM_SLOW_REGISTER_OFFSET(c, i))

/* It's not possible to have a single macro JITTER_REGISTER taking an index and
   expanding to either a fast or a slow register lvalue, due to CPP conditional
   limitations.  This restriction is unfortunate, but we have to live with it
   as long as we don't switch to a different preprocessor.
   What we can have is a set of zero-argument macros each expanding to a register
   lvalue, for *a limited number* of registers.  Here we define access macros for
   every fast register plus a reasonable number (currently 32) of slow registers,
   per class. */
#define JITTER_REGISTER_r_0    JITTER_SLOW_REGISTER(r, 0)
#define JITTER_REGISTER_r_1    JITTER_SLOW_REGISTER(r, 1)
#define JITTER_REGISTER_r_2    JITTER_SLOW_REGISTER(r, 2)
#define JITTER_REGISTER_r_3    JITTER_SLOW_REGISTER(r, 3)
#define JITTER_REGISTER_r_4    JITTER_SLOW_REGISTER(r, 4)
#define JITTER_REGISTER_r_5    JITTER_SLOW_REGISTER(r, 5)
#define JITTER_REGISTER_r_6    JITTER_SLOW_REGISTER(r, 6)
#define JITTER_REGISTER_r_7    JITTER_SLOW_REGISTER(r, 7)
#define JITTER_REGISTER_r_8    JITTER_SLOW_REGISTER(r, 8)
#define JITTER_REGISTER_r_9    JITTER_SLOW_REGISTER(r, 9)
#define JITTER_REGISTER_r_10   JITTER_SLOW_REGISTER(r, 10)
#define JITTER_REGISTER_r_11   JITTER_SLOW_REGISTER(r, 11)
#define JITTER_REGISTER_r_12   JITTER_SLOW_REGISTER(r, 12)
#define JITTER_REGISTER_r_13   JITTER_SLOW_REGISTER(r, 13)
#define JITTER_REGISTER_r_14   JITTER_SLOW_REGISTER(r, 14)
#define JITTER_REGISTER_r_15   JITTER_SLOW_REGISTER(r, 15)
#define JITTER_REGISTER_r_16   JITTER_SLOW_REGISTER(r, 16)
#define JITTER_REGISTER_r_17   JITTER_SLOW_REGISTER(r, 17)
#define JITTER_REGISTER_r_18   JITTER_SLOW_REGISTER(r, 18)
#define JITTER_REGISTER_r_19   JITTER_SLOW_REGISTER(r, 19)
#define JITTER_REGISTER_r_20   JITTER_SLOW_REGISTER(r, 20)
#define JITTER_REGISTER_r_21   JITTER_SLOW_REGISTER(r, 21)
#define JITTER_REGISTER_r_22   JITTER_SLOW_REGISTER(r, 22)
#define JITTER_REGISTER_r_23   JITTER_SLOW_REGISTER(r, 23)
#define JITTER_REGISTER_r_24   JITTER_SLOW_REGISTER(r, 24)
#define JITTER_REGISTER_r_25   JITTER_SLOW_REGISTER(r, 25)
#define JITTER_REGISTER_r_26   JITTER_SLOW_REGISTER(r, 26)
#define JITTER_REGISTER_r_27   JITTER_SLOW_REGISTER(r, 27)
#define JITTER_REGISTER_r_28   JITTER_SLOW_REGISTER(r, 28)
#define JITTER_REGISTER_r_29   JITTER_SLOW_REGISTER(r, 29)
#define JITTER_REGISTER_r_30   JITTER_SLOW_REGISTER(r, 30)
#define JITTER_REGISTER_r_31   JITTER_SLOW_REGISTER(r, 31)


#ifdef JITTER_DISPATCH_NO_THREADING

/* Reserve the scratch register, if any. */
#ifdef JITTER_SCRATCH_REGISTER
  register union jitter_word
  jitter_residual_argument_scratch_register_variable asm (JITTER_STRINGIFY(JITTER_SCRATCH_REGISTER));
#endif // #ifdef JITTER_SCRATCH_REGISTER

/* Reserve The Array base register. */
#ifndef JITTER_BASE_REGISTER
# error "the machine does not define JITTER_BASE_REGISTER"
#else
register char * restrict
jitterlispvm_array_base_register_variable asm (JITTER_STRINGIFY(JITTER_BASE_REGISTER));
#endif // #ifndef JITTER_BASE_REGISTER

/* Reserve registers for our 4 residual arguments.  If this particular VM doesn't
   need all of those supported by the assembly machine then reserve only the first
   ones.  If, on the other hand, we need more residual arguments than we have
   available registers, use CPP macros to map the remaining residual arguments
   to memory locations relative to the base, with constant offsets. */

/* Define a macro for the 0-th residual as a register, or as a residual
   memory slot.  Also define a macro expanding to inline asm code with
   output constraints on the appropriate register or memory, to let GCC
   know that its value has been changed by unknown code. */
#if (0 < JITTER_RESIDUAL_REGISTER_NO)
  register union jitter_word
  jitter_residual_argument_0_register_variable asm (JITTER_STRINGIFY(JITTER_RESIDUAL_REGISTER_0));
# define JITTER_RESIDUAL_ARGUMENT_0               \
    jitter_residual_argument_0_register_variable
# define JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY                 \
    JITTER_MARK_REGISTER_AS_SET_BY_ASSEMBLY(jitter_residual_argument_0_register_variable)
#else
# define JITTER_RESIDUAL_ARGUMENT_0  \
    (* (union jitter_word *)                 \
       (jitter_array_base + JITTERLISPVM_RESIDUAL_OFFSET(0)))
# define JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY                    \
    JITTER_MARK_MEMORY_AS_SET_BY_ASSEMBLY(JITTER_RESIDUAL_ARGUMENT_0)
#endif // #if (0 < JITTER_RESIDUAL_REGISTER_NO)

/* Define a macro for the 1-th residual as a register, or as a residual
   memory slot.  Also define a macro expanding to inline asm code with
   output constraints on the appropriate register or memory, to let GCC
   know that its value has been changed by unknown code. */
#if (1 < JITTER_RESIDUAL_REGISTER_NO)
  register union jitter_word
  jitter_residual_argument_1_register_variable asm (JITTER_STRINGIFY(JITTER_RESIDUAL_REGISTER_1));
# define JITTER_RESIDUAL_ARGUMENT_1               \
    jitter_residual_argument_1_register_variable
# define JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY                 \
    JITTER_MARK_REGISTER_AS_SET_BY_ASSEMBLY(jitter_residual_argument_1_register_variable)
#else
# define JITTER_RESIDUAL_ARGUMENT_1  \
    (* (union jitter_word *)                 \
       (jitter_array_base + JITTERLISPVM_RESIDUAL_OFFSET(1)))
# define JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY                    \
    JITTER_MARK_MEMORY_AS_SET_BY_ASSEMBLY(JITTER_RESIDUAL_ARGUMENT_1)
#endif // #if (1 < JITTER_RESIDUAL_REGISTER_NO)

/* Define a macro for the 2-th residual as a register, or as a residual
   memory slot.  Also define a macro expanding to inline asm code with
   output constraints on the appropriate register or memory, to let GCC
   know that its value has been changed by unknown code. */
#if (2 < JITTER_RESIDUAL_REGISTER_NO)
  register union jitter_word
  jitter_residual_argument_2_register_variable asm (JITTER_STRINGIFY(JITTER_RESIDUAL_REGISTER_2));
# define JITTER_RESIDUAL_ARGUMENT_2               \
    jitter_residual_argument_2_register_variable
# define JITTER_MARK_RESIDUAL_2_AS_SET_BY_ASSEMBLY                 \
    JITTER_MARK_REGISTER_AS_SET_BY_ASSEMBLY(jitter_residual_argument_2_register_variable)
#else
# define JITTER_RESIDUAL_ARGUMENT_2  \
    (* (union jitter_word *)                 \
       (jitter_array_base + JITTERLISPVM_RESIDUAL_OFFSET(2)))
# define JITTER_MARK_RESIDUAL_2_AS_SET_BY_ASSEMBLY                    \
    JITTER_MARK_MEMORY_AS_SET_BY_ASSEMBLY(JITTER_RESIDUAL_ARGUMENT_2)
#endif // #if (2 < JITTER_RESIDUAL_REGISTER_NO)

/* Define a macro for the 3-th residual as a register, or as a residual
   memory slot.  Also define a macro expanding to inline asm code with
   output constraints on the appropriate register or memory, to let GCC
   know that its value has been changed by unknown code. */
#if (3 < JITTER_RESIDUAL_REGISTER_NO)
  register union jitter_word
  jitter_residual_argument_3_register_variable asm (JITTER_STRINGIFY(JITTER_RESIDUAL_REGISTER_3));
# define JITTER_RESIDUAL_ARGUMENT_3               \
    jitter_residual_argument_3_register_variable
# define JITTER_MARK_RESIDUAL_3_AS_SET_BY_ASSEMBLY                 \
    JITTER_MARK_REGISTER_AS_SET_BY_ASSEMBLY(jitter_residual_argument_3_register_variable)
#else
# define JITTER_RESIDUAL_ARGUMENT_3  \
    (* (union jitter_word *)                 \
       (jitter_array_base + JITTERLISPVM_RESIDUAL_OFFSET(3)))
# define JITTER_MARK_RESIDUAL_3_AS_SET_BY_ASSEMBLY                    \
    JITTER_MARK_MEMORY_AS_SET_BY_ASSEMBLY(JITTER_RESIDUAL_ARGUMENT_3)
#endif // #if (3 < JITTER_RESIDUAL_REGISTER_NO)

/* The global register values we reserve in this compilation unit are
   callee-save: the called function is supposed to save them before
   setting them, and restore them to their previous value before
   returning to the caller.  Of course this is not done automatically
   in this compilation unit, so we have to do it by hand.  Notice that
   every variable allocated to a register by GCC will not use the
   registers we reserved, so we can be sure that, if we save our
   global register variables before setting them for the first time,
   their values will be the ones we want to retain. */

/* The buffer where I keep the original register values needs to hold
   every residual register, plus possibly the scratch register and the
   residual base; those two registers are not always used, but allocating
   just two words more costs essentially nothing and lets me simplify
   the code a little.  The two words are not written or read unless
   needed. */
#define JITTERLISPVM_REGISTER_BUFFER_ELEMENT_NO (JITTER_RESIDUAL_REGISTER_NO + 2)
__attribute__ ((noinline, cold))

static void
jitterlispvm_save_registers (union jitter_word *buffer)
{
  buffer [0].pointer = (union jitter_word*) jitterlispvm_array_base_register_variable;
#ifdef JITTER_SCRATCH_REGISTER
  buffer [1] = jitter_residual_argument_scratch_register_variable;
#endif // #ifdef JITTER_SCRATCH_REGISTER
#if (0 < JITTER_RESIDUAL_REGISTER_NO)
  buffer [0 + 2] = JITTER_RESIDUAL_ARGUMENT_0;
#endif // #if (0 < JITTER_RESIDUAL_REGISTER_NO)
#if (1 < JITTER_RESIDUAL_REGISTER_NO)
  buffer [1 + 2] = JITTER_RESIDUAL_ARGUMENT_1;
#endif // #if (1 < JITTER_RESIDUAL_REGISTER_NO)
#if (2 < JITTER_RESIDUAL_REGISTER_NO)
  buffer [2 + 2] = JITTER_RESIDUAL_ARGUMENT_2;
#endif // #if (2 < JITTER_RESIDUAL_REGISTER_NO)
#if (3 < JITTER_RESIDUAL_REGISTER_NO)
  buffer [3 + 2] = JITTER_RESIDUAL_ARGUMENT_3;
#endif // #if (3 < JITTER_RESIDUAL_REGISTER_NO)
}

__attribute__ ((noinline, cold))
static void
jitterlispvm_restore_registers (const union jitter_word *buffer)
{
  jitterlispvm_array_base_register_variable = (char *) buffer [0].pointer;
#ifdef JITTER_SCRATCH_REGISTER
  jitter_residual_argument_scratch_register_variable = buffer [1];
#endif // #ifdef JITTER_SCRATCH_REGISTER
#if (0 < JITTER_RESIDUAL_REGISTER_NO)
  JITTER_RESIDUAL_ARGUMENT_0 = buffer [0 + 2];
#endif // #if (0 < JITTER_RESIDUAL_REGISTER_NO)
#if (1 < JITTER_RESIDUAL_REGISTER_NO)
  JITTER_RESIDUAL_ARGUMENT_1 = buffer [1 + 2];
#endif // #if (1 < JITTER_RESIDUAL_REGISTER_NO)
#if (2 < JITTER_RESIDUAL_REGISTER_NO)
  JITTER_RESIDUAL_ARGUMENT_2 = buffer [2 + 2];
#endif // #if (2 < JITTER_RESIDUAL_REGISTER_NO)
#if (3 < JITTER_RESIDUAL_REGISTER_NO)
  JITTER_RESIDUAL_ARGUMENT_3 = buffer [3 + 2];
#endif // #if (3 < JITTER_RESIDUAL_REGISTER_NO)
}

#endif // #ifdef JITTER_DISPATCH_NO_THREADING


/* The following stack operations (without the initial state
   argument) can be used inside instruction code blocks.
   Notice that macros with the same "JITTERLISPVM_" names are
   defined in the generated header to be used out of VM code,
   but those alternative definitions have an additional first
   argument, a VM state pointer. */

/* Wrapper definition of the top operation for the
   TOS-optimized stack "mainstack". */
#undef JITTER_TOP_MAINSTACK
#undef JITTERLISPVM_TOP_MAINSTACK
#define JITTERLISPVM_TOP_MAINSTACK /* The preferred name. */ \
  JITTER_TOP_MAINSTACK
#define JITTER_TOP_MAINSTACK()  \
  JITTER_STACK_TOS_TOP (jitterlisp_object,  \
    jitter_state_runtime. /* not an error */,  \
    mainstack  \
    )
/* Wrapper definition of the under_top operation for the
   TOS-optimized stack "mainstack". */
#undef JITTER_UNDER_TOP_MAINSTACK
#undef JITTERLISPVM_UNDER_TOP_MAINSTACK
#define JITTERLISPVM_UNDER_TOP_MAINSTACK /* The preferred name. */ \
  JITTER_UNDER_TOP_MAINSTACK
#define JITTER_UNDER_TOP_MAINSTACK()  \
  JITTER_STACK_TOS_UNDER_TOP (jitterlisp_object,  \
    jitter_state_runtime. /* not an error */,  \
    mainstack  \
    )
/* Wrapper definition of the at_depth operation for the
   TOS-optimized stack "mainstack". */
#undef JITTER_AT_DEPTH_MAINSTACK
#undef JITTERLISPVM_AT_DEPTH_MAINSTACK
#define JITTERLISPVM_AT_DEPTH_MAINSTACK /* The preferred name. */ \
  JITTER_AT_DEPTH_MAINSTACK
#define JITTER_AT_DEPTH_MAINSTACK(x0)  \
  JITTER_STACK_TOS_AT_DEPTH (jitterlisp_object,  \
    jitter_state_runtime. /* not an error */,  \
    mainstack  \
    , x0)
/* Wrapper definition of the at_nonzero_depth operation for the
   TOS-optimized stack "mainstack". */
#undef JITTER_AT_NONZERO_DEPTH_MAINSTACK
#undef JITTERLISPVM_AT_NONZERO_DEPTH_MAINSTACK
#define JITTERLISPVM_AT_NONZERO_DEPTH_MAINSTACK /* The preferred name. */ \
  JITTER_AT_NONZERO_DEPTH_MAINSTACK
#define JITTER_AT_NONZERO_DEPTH_MAINSTACK(x0)  \
  JITTER_STACK_TOS_AT_NONZERO_DEPTH (jitterlisp_object,  \
    jitter_state_runtime. /* not an error */,  \
    mainstack  \
    , x0)
/* Wrapper definition of the set_at_depth operation for the
   TOS-optimized stack "mainstack". */
#undef JITTER_SET_AT_DEPTH_MAINSTACK
#undef JITTERLISPVM_SET_AT_DEPTH_MAINSTACK
#define JITTERLISPVM_SET_AT_DEPTH_MAINSTACK /* The preferred name. */ \
  JITTER_SET_AT_DEPTH_MAINSTACK
#define JITTER_SET_AT_DEPTH_MAINSTACK(x0, x1)  \
  JITTER_STACK_TOS_SET_AT_DEPTH (jitterlisp_object,  \
    jitter_state_runtime. /* not an error */,  \
    mainstack  \
    , x0, x1)
/* Wrapper definition of the set_at_nonzero_depth operation for the
   TOS-optimized stack "mainstack". */
#undef JITTER_SET_AT_NONZERO_DEPTH_MAINSTACK
#undef JITTERLISPVM_SET_AT_NONZERO_DEPTH_MAINSTACK
#define JITTERLISPVM_SET_AT_NONZERO_DEPTH_MAINSTACK /* The preferred name. */ \
  JITTER_SET_AT_NONZERO_DEPTH_MAINSTACK
#define JITTER_SET_AT_NONZERO_DEPTH_MAINSTACK(x0, x1)  \
  JITTER_STACK_TOS_SET_AT_NONZERO_DEPTH (jitterlisp_object,  \
    jitter_state_runtime. /* not an error */,  \
    mainstack  \
    , x0, x1)
/* Wrapper definition of the push_unspecified operation for the
   TOS-optimized stack "mainstack". */
#undef JITTER_PUSH_UNSPECIFIED_MAINSTACK
#undef JITTERLISPVM_PUSH_UNSPECIFIED_MAINSTACK
#define JITTERLISPVM_PUSH_UNSPECIFIED_MAINSTACK /* The preferred name. */ \
  JITTER_PUSH_UNSPECIFIED_MAINSTACK
#define JITTER_PUSH_UNSPECIFIED_MAINSTACK()  \
  JITTER_STACK_TOS_PUSH_UNSPECIFIED (jitterlisp_object,  \
    jitter_state_runtime. /* not an error */,  \
    mainstack  \
    )
/* Wrapper definition of the push operation for the
   TOS-optimized stack "mainstack". */
#undef JITTER_PUSH_MAINSTACK
#undef JITTERLISPVM_PUSH_MAINSTACK
#define JITTERLISPVM_PUSH_MAINSTACK /* The preferred name. */ \
  JITTER_PUSH_MAINSTACK
#define JITTER_PUSH_MAINSTACK(x0)  \
  JITTER_STACK_TOS_PUSH (jitterlisp_object,  \
    jitter_state_runtime. /* not an error */,  \
    mainstack  \
    , x0)
/* Wrapper definition of the under_push_unspecified operation for the
   TOS-optimized stack "mainstack". */
#undef JITTER_UNDER_PUSH_UNSPECIFIED_MAINSTACK
#undef JITTERLISPVM_UNDER_PUSH_UNSPECIFIED_MAINSTACK
#define JITTERLISPVM_UNDER_PUSH_UNSPECIFIED_MAINSTACK /* The preferred name. */ \
  JITTER_UNDER_PUSH_UNSPECIFIED_MAINSTACK
#define JITTER_UNDER_PUSH_UNSPECIFIED_MAINSTACK()  \
  JITTER_STACK_TOS_UNDER_PUSH_UNSPECIFIED (jitterlisp_object,  \
    jitter_state_runtime. /* not an error */,  \
    mainstack  \
    )
/* Wrapper definition of the under_push operation for the
   TOS-optimized stack "mainstack". */
#undef JITTER_UNDER_PUSH_MAINSTACK
#undef JITTERLISPVM_UNDER_PUSH_MAINSTACK
#define JITTERLISPVM_UNDER_PUSH_MAINSTACK /* The preferred name. */ \
  JITTER_UNDER_PUSH_MAINSTACK
#define JITTER_UNDER_PUSH_MAINSTACK(x0)  \
  JITTER_STACK_TOS_UNDER_PUSH (jitterlisp_object,  \
    jitter_state_runtime. /* not an error */,  \
    mainstack  \
    , x0)
/* Wrapper definition of the drop operation for the
   TOS-optimized stack "mainstack". */
#undef JITTER_DROP_MAINSTACK
#undef JITTERLISPVM_DROP_MAINSTACK
#define JITTERLISPVM_DROP_MAINSTACK /* The preferred name. */ \
  JITTER_DROP_MAINSTACK
#define JITTER_DROP_MAINSTACK()  \
  JITTER_STACK_TOS_DROP (jitterlisp_object,  \
    jitter_state_runtime. /* not an error */,  \
    mainstack  \
    )
/* Wrapper definition of the dup operation for the
   TOS-optimized stack "mainstack". */
#undef JITTER_DUP_MAINSTACK
#undef JITTERLISPVM_DUP_MAINSTACK
#define JITTERLISPVM_DUP_MAINSTACK /* The preferred name. */ \
  JITTER_DUP_MAINSTACK
#define JITTER_DUP_MAINSTACK()  \
  JITTER_STACK_TOS_DUP (jitterlisp_object,  \
    jitter_state_runtime. /* not an error */,  \
    mainstack  \
    )
/* Wrapper definition of the swap operation for the
   TOS-optimized stack "mainstack". */
#undef JITTER_SWAP_MAINSTACK
#undef JITTERLISPVM_SWAP_MAINSTACK
#define JITTERLISPVM_SWAP_MAINSTACK /* The preferred name. */ \
  JITTER_SWAP_MAINSTACK
#define JITTER_SWAP_MAINSTACK()  \
  JITTER_STACK_TOS_SWAP (jitterlisp_object,  \
    jitter_state_runtime. /* not an error */,  \
    mainstack  \
    )
/* Wrapper definition of the quake operation for the
   TOS-optimized stack "mainstack". */
#undef JITTER_QUAKE_MAINSTACK
#undef JITTERLISPVM_QUAKE_MAINSTACK
#define JITTERLISPVM_QUAKE_MAINSTACK /* The preferred name. */ \
  JITTER_QUAKE_MAINSTACK
#define JITTER_QUAKE_MAINSTACK()  \
  JITTER_STACK_TOS_QUAKE (jitterlisp_object,  \
    jitter_state_runtime. /* not an error */,  \
    mainstack  \
    )
/* Wrapper definition of the over operation for the
   TOS-optimized stack "mainstack". */
#undef JITTER_OVER_MAINSTACK
#undef JITTERLISPVM_OVER_MAINSTACK
#define JITTERLISPVM_OVER_MAINSTACK /* The preferred name. */ \
  JITTER_OVER_MAINSTACK
#define JITTER_OVER_MAINSTACK()  \
  JITTER_STACK_TOS_OVER (jitterlisp_object,  \
    jitter_state_runtime. /* not an error */,  \
    mainstack  \
    )
/* Wrapper definition of the tuck operation for the
   TOS-optimized stack "mainstack". */
#undef JITTER_TUCK_MAINSTACK
#undef JITTERLISPVM_TUCK_MAINSTACK
#define JITTERLISPVM_TUCK_MAINSTACK /* The preferred name. */ \
  JITTER_TUCK_MAINSTACK
#define JITTER_TUCK_MAINSTACK()  \
  JITTER_STACK_TOS_TUCK (jitterlisp_object,  \
    jitter_state_runtime. /* not an error */,  \
    mainstack  \
    )
/* Wrapper definition of the nip operation for the
   TOS-optimized stack "mainstack". */
#undef JITTER_NIP_MAINSTACK
#undef JITTERLISPVM_NIP_MAINSTACK
#define JITTERLISPVM_NIP_MAINSTACK /* The preferred name. */ \
  JITTER_NIP_MAINSTACK
#define JITTER_NIP_MAINSTACK()  \
  JITTER_STACK_TOS_NIP (jitterlisp_object,  \
    jitter_state_runtime. /* not an error */,  \
    mainstack  \
    )
/* Wrapper definition of the rot operation for the
   TOS-optimized stack "mainstack". */
#undef JITTER_ROT_MAINSTACK
#undef JITTERLISPVM_ROT_MAINSTACK
#define JITTERLISPVM_ROT_MAINSTACK /* The preferred name. */ \
  JITTER_ROT_MAINSTACK
#define JITTER_ROT_MAINSTACK()  \
  JITTER_STACK_TOS_ROT (jitterlisp_object,  \
    jitter_state_runtime. /* not an error */,  \
    mainstack  \
    )
/* Wrapper definition of the mrot operation for the
   TOS-optimized stack "mainstack". */
#undef JITTER_MROT_MAINSTACK
#undef JITTERLISPVM_MROT_MAINSTACK
#define JITTERLISPVM_MROT_MAINSTACK /* The preferred name. */ \
  JITTER_MROT_MAINSTACK
#define JITTER_MROT_MAINSTACK()  \
  JITTER_STACK_TOS_MROT (jitterlisp_object,  \
    jitter_state_runtime. /* not an error */,  \
    mainstack  \
    )
/* Wrapper definition of the roll operation for the
   TOS-optimized stack "mainstack". */
#undef JITTER_ROLL_MAINSTACK
#undef JITTERLISPVM_ROLL_MAINSTACK
#define JITTERLISPVM_ROLL_MAINSTACK /* The preferred name. */ \
  JITTER_ROLL_MAINSTACK
#define JITTER_ROLL_MAINSTACK(x0)  \
  JITTER_STACK_TOS_ROLL (jitterlisp_object,  \
    jitter_state_runtime. /* not an error */,  \
    mainstack  \
    , x0)
/* Wrapper definition of the mroll operation for the
   TOS-optimized stack "mainstack". */
#undef JITTER_MROLL_MAINSTACK
#undef JITTERLISPVM_MROLL_MAINSTACK
#define JITTERLISPVM_MROLL_MAINSTACK /* The preferred name. */ \
  JITTER_MROLL_MAINSTACK
#define JITTER_MROLL_MAINSTACK(x0)  \
  JITTER_STACK_TOS_MROLL (jitterlisp_object,  \
    jitter_state_runtime. /* not an error */,  \
    mainstack  \
    , x0)
/* Wrapper definition of the slide operation for the
   TOS-optimized stack "mainstack". */
#undef JITTER_SLIDE_MAINSTACK
#undef JITTERLISPVM_SLIDE_MAINSTACK
#define JITTERLISPVM_SLIDE_MAINSTACK /* The preferred name. */ \
  JITTER_SLIDE_MAINSTACK
#define JITTER_SLIDE_MAINSTACK(x0, x1)  \
  JITTER_STACK_TOS_SLIDE (jitterlisp_object,  \
    jitter_state_runtime. /* not an error */,  \
    mainstack  \
    , x0, x1)
/* Wrapper definition of the whirl operation for the
   TOS-optimized stack "mainstack". */
#undef JITTER_WHIRL_MAINSTACK
#undef JITTERLISPVM_WHIRL_MAINSTACK
#define JITTERLISPVM_WHIRL_MAINSTACK /* The preferred name. */ \
  JITTER_WHIRL_MAINSTACK
#define JITTER_WHIRL_MAINSTACK(x0)  \
  JITTER_STACK_TOS_WHIRL (jitterlisp_object,  \
    jitter_state_runtime. /* not an error */,  \
    mainstack  \
    , x0)
/* Wrapper definition of the bulge operation for the
   TOS-optimized stack "mainstack". */
#undef JITTER_BULGE_MAINSTACK
#undef JITTERLISPVM_BULGE_MAINSTACK
#define JITTERLISPVM_BULGE_MAINSTACK /* The preferred name. */ \
  JITTER_BULGE_MAINSTACK
#define JITTER_BULGE_MAINSTACK(x0)  \
  JITTER_STACK_TOS_BULGE (jitterlisp_object,  \
    jitter_state_runtime. /* not an error */,  \
    mainstack  \
    , x0)
/* Wrapper definition of the height operation for the
   TOS-optimized stack "mainstack". */
#undef JITTER_HEIGHT_MAINSTACK
#undef JITTERLISPVM_HEIGHT_MAINSTACK
#define JITTERLISPVM_HEIGHT_MAINSTACK /* The preferred name. */ \
  JITTER_HEIGHT_MAINSTACK
#define JITTER_HEIGHT_MAINSTACK()  \
  JITTER_STACK_TOS_HEIGHT (jitterlisp_object,  \
    jitter_state_runtime. /* not an error */,  \
    mainstack  \
    )
/* Wrapper definition of the set_height operation for the
   TOS-optimized stack "mainstack". */
#undef JITTER_SET_HEIGHT_MAINSTACK
#undef JITTERLISPVM_SET_HEIGHT_MAINSTACK
#define JITTERLISPVM_SET_HEIGHT_MAINSTACK /* The preferred name. */ \
  JITTER_SET_HEIGHT_MAINSTACK
#define JITTER_SET_HEIGHT_MAINSTACK(x0)  \
  JITTER_STACK_TOS_SET_HEIGHT (jitterlisp_object,  \
    jitter_state_runtime. /* not an error */,  \
    mainstack  \
    , x0)
/* Wrapper definition of the reverse operation for the
   TOS-optimized stack "mainstack". */
#undef JITTER_REVERSE_MAINSTACK
#undef JITTERLISPVM_REVERSE_MAINSTACK
#define JITTERLISPVM_REVERSE_MAINSTACK /* The preferred name. */ \
  JITTER_REVERSE_MAINSTACK
#define JITTER_REVERSE_MAINSTACK(x0)  \
  JITTER_STACK_TOS_REVERSE (jitterlisp_object,  \
    jitter_state_runtime. /* not an error */,  \
    mainstack  \
    , x0)
/* Wrapper definition of the unary operation for the
   TOS-optimized stack "mainstack". */
#undef JITTER_UNARY_MAINSTACK
#undef JITTERLISPVM_UNARY_MAINSTACK
#define JITTERLISPVM_UNARY_MAINSTACK /* The preferred name. */ \
  JITTER_UNARY_MAINSTACK
#define JITTER_UNARY_MAINSTACK(x0)  \
  JITTER_STACK_TOS_UNARY (jitterlisp_object,  \
    jitter_state_runtime. /* not an error */,  \
    mainstack  \
    , x0)
/* Wrapper definition of the binary operation for the
   TOS-optimized stack "mainstack". */
#undef JITTER_BINARY_MAINSTACK
#undef JITTERLISPVM_BINARY_MAINSTACK
#define JITTERLISPVM_BINARY_MAINSTACK /* The preferred name. */ \
  JITTER_BINARY_MAINSTACK
#define JITTER_BINARY_MAINSTACK(x0)  \
  JITTER_STACK_TOS_BINARY (jitterlisp_object,  \
    jitter_state_runtime. /* not an error */,  \
    mainstack  \
    , x0)
/* Wrapper definition of the top operation for the
   non-TOS-optimized stack "returnstack". */
#undef JITTER_TOP_RETURNSTACK
#undef JITTERLISPVM_TOP_RETURNSTACK
#define JITTERLISPVM_TOP_RETURNSTACK /* The preferred name. */ \
  JITTER_TOP_RETURNSTACK
#define JITTER_TOP_RETURNSTACK()  \
  JITTER_STACK_NTOS_TOP (jitterlisp_object,  \
    jitter_state_runtime. /* not an error */,  \
    returnstack  \
    )
/* Wrapper definition of the under_top operation for the
   non-TOS-optimized stack "returnstack". */
#undef JITTER_UNDER_TOP_RETURNSTACK
#undef JITTERLISPVM_UNDER_TOP_RETURNSTACK
#define JITTERLISPVM_UNDER_TOP_RETURNSTACK /* The preferred name. */ \
  JITTER_UNDER_TOP_RETURNSTACK
#define JITTER_UNDER_TOP_RETURNSTACK()  \
  JITTER_STACK_NTOS_UNDER_TOP (jitterlisp_object,  \
    jitter_state_runtime. /* not an error */,  \
    returnstack  \
    )
/* Wrapper definition of the at_depth operation for the
   non-TOS-optimized stack "returnstack". */
#undef JITTER_AT_DEPTH_RETURNSTACK
#undef JITTERLISPVM_AT_DEPTH_RETURNSTACK
#define JITTERLISPVM_AT_DEPTH_RETURNSTACK /* The preferred name. */ \
  JITTER_AT_DEPTH_RETURNSTACK
#define JITTER_AT_DEPTH_RETURNSTACK(x0)  \
  JITTER_STACK_NTOS_AT_DEPTH (jitterlisp_object,  \
    jitter_state_runtime. /* not an error */,  \
    returnstack  \
    , x0)
/* Wrapper definition of the at_nonzero_depth operation for the
   non-TOS-optimized stack "returnstack". */
#undef JITTER_AT_NONZERO_DEPTH_RETURNSTACK
#undef JITTERLISPVM_AT_NONZERO_DEPTH_RETURNSTACK
#define JITTERLISPVM_AT_NONZERO_DEPTH_RETURNSTACK /* The preferred name. */ \
  JITTER_AT_NONZERO_DEPTH_RETURNSTACK
#define JITTER_AT_NONZERO_DEPTH_RETURNSTACK(x0)  \
  JITTER_STACK_NTOS_AT_NONZERO_DEPTH (jitterlisp_object,  \
    jitter_state_runtime. /* not an error */,  \
    returnstack  \
    , x0)
/* Wrapper definition of the set_at_depth operation for the
   non-TOS-optimized stack "returnstack". */
#undef JITTER_SET_AT_DEPTH_RETURNSTACK
#undef JITTERLISPVM_SET_AT_DEPTH_RETURNSTACK
#define JITTERLISPVM_SET_AT_DEPTH_RETURNSTACK /* The preferred name. */ \
  JITTER_SET_AT_DEPTH_RETURNSTACK
#define JITTER_SET_AT_DEPTH_RETURNSTACK(x0, x1)  \
  JITTER_STACK_NTOS_SET_AT_DEPTH (jitterlisp_object,  \
    jitter_state_runtime. /* not an error */,  \
    returnstack  \
    , x0, x1)
/* Wrapper definition of the set_at_nonzero_depth operation for the
   non-TOS-optimized stack "returnstack". */
#undef JITTER_SET_AT_NONZERO_DEPTH_RETURNSTACK
#undef JITTERLISPVM_SET_AT_NONZERO_DEPTH_RETURNSTACK
#define JITTERLISPVM_SET_AT_NONZERO_DEPTH_RETURNSTACK /* The preferred name. */ \
  JITTER_SET_AT_NONZERO_DEPTH_RETURNSTACK
#define JITTER_SET_AT_NONZERO_DEPTH_RETURNSTACK(x0, x1)  \
  JITTER_STACK_NTOS_SET_AT_NONZERO_DEPTH (jitterlisp_object,  \
    jitter_state_runtime. /* not an error */,  \
    returnstack  \
    , x0, x1)
/* Wrapper definition of the push_unspecified operation for the
   non-TOS-optimized stack "returnstack". */
#undef JITTER_PUSH_UNSPECIFIED_RETURNSTACK
#undef JITTERLISPVM_PUSH_UNSPECIFIED_RETURNSTACK
#define JITTERLISPVM_PUSH_UNSPECIFIED_RETURNSTACK /* The preferred name. */ \
  JITTER_PUSH_UNSPECIFIED_RETURNSTACK
#define JITTER_PUSH_UNSPECIFIED_RETURNSTACK()  \
  JITTER_STACK_NTOS_PUSH_UNSPECIFIED (jitterlisp_object,  \
    jitter_state_runtime. /* not an error */,  \
    returnstack  \
    )
/* Wrapper definition of the push operation for the
   non-TOS-optimized stack "returnstack". */
#undef JITTER_PUSH_RETURNSTACK
#undef JITTERLISPVM_PUSH_RETURNSTACK
#define JITTERLISPVM_PUSH_RETURNSTACK /* The preferred name. */ \
  JITTER_PUSH_RETURNSTACK
#define JITTER_PUSH_RETURNSTACK(x0)  \
  JITTER_STACK_NTOS_PUSH (jitterlisp_object,  \
    jitter_state_runtime. /* not an error */,  \
    returnstack  \
    , x0)
/* Wrapper definition of the under_push_unspecified operation for the
   non-TOS-optimized stack "returnstack". */
#undef JITTER_UNDER_PUSH_UNSPECIFIED_RETURNSTACK
#undef JITTERLISPVM_UNDER_PUSH_UNSPECIFIED_RETURNSTACK
#define JITTERLISPVM_UNDER_PUSH_UNSPECIFIED_RETURNSTACK /* The preferred name. */ \
  JITTER_UNDER_PUSH_UNSPECIFIED_RETURNSTACK
#define JITTER_UNDER_PUSH_UNSPECIFIED_RETURNSTACK()  \
  JITTER_STACK_NTOS_UNDER_PUSH_UNSPECIFIED (jitterlisp_object,  \
    jitter_state_runtime. /* not an error */,  \
    returnstack  \
    )
/* Wrapper definition of the under_push operation for the
   non-TOS-optimized stack "returnstack". */
#undef JITTER_UNDER_PUSH_RETURNSTACK
#undef JITTERLISPVM_UNDER_PUSH_RETURNSTACK
#define JITTERLISPVM_UNDER_PUSH_RETURNSTACK /* The preferred name. */ \
  JITTER_UNDER_PUSH_RETURNSTACK
#define JITTER_UNDER_PUSH_RETURNSTACK(x0)  \
  JITTER_STACK_NTOS_UNDER_PUSH (jitterlisp_object,  \
    jitter_state_runtime. /* not an error */,  \
    returnstack  \
    , x0)
/* Wrapper definition of the drop operation for the
   non-TOS-optimized stack "returnstack". */
#undef JITTER_DROP_RETURNSTACK
#undef JITTERLISPVM_DROP_RETURNSTACK
#define JITTERLISPVM_DROP_RETURNSTACK /* The preferred name. */ \
  JITTER_DROP_RETURNSTACK
#define JITTER_DROP_RETURNSTACK()  \
  JITTER_STACK_NTOS_DROP (jitterlisp_object,  \
    jitter_state_runtime. /* not an error */,  \
    returnstack  \
    )
/* Wrapper definition of the dup operation for the
   non-TOS-optimized stack "returnstack". */
#undef JITTER_DUP_RETURNSTACK
#undef JITTERLISPVM_DUP_RETURNSTACK
#define JITTERLISPVM_DUP_RETURNSTACK /* The preferred name. */ \
  JITTER_DUP_RETURNSTACK
#define JITTER_DUP_RETURNSTACK()  \
  JITTER_STACK_NTOS_DUP (jitterlisp_object,  \
    jitter_state_runtime. /* not an error */,  \
    returnstack  \
    )
/* Wrapper definition of the swap operation for the
   non-TOS-optimized stack "returnstack". */
#undef JITTER_SWAP_RETURNSTACK
#undef JITTERLISPVM_SWAP_RETURNSTACK
#define JITTERLISPVM_SWAP_RETURNSTACK /* The preferred name. */ \
  JITTER_SWAP_RETURNSTACK
#define JITTER_SWAP_RETURNSTACK()  \
  JITTER_STACK_NTOS_SWAP (jitterlisp_object,  \
    jitter_state_runtime. /* not an error */,  \
    returnstack  \
    )
/* Wrapper definition of the quake operation for the
   non-TOS-optimized stack "returnstack". */
#undef JITTER_QUAKE_RETURNSTACK
#undef JITTERLISPVM_QUAKE_RETURNSTACK
#define JITTERLISPVM_QUAKE_RETURNSTACK /* The preferred name. */ \
  JITTER_QUAKE_RETURNSTACK
#define JITTER_QUAKE_RETURNSTACK()  \
  JITTER_STACK_NTOS_QUAKE (jitterlisp_object,  \
    jitter_state_runtime. /* not an error */,  \
    returnstack  \
    )
/* Wrapper definition of the over operation for the
   non-TOS-optimized stack "returnstack". */
#undef JITTER_OVER_RETURNSTACK
#undef JITTERLISPVM_OVER_RETURNSTACK
#define JITTERLISPVM_OVER_RETURNSTACK /* The preferred name. */ \
  JITTER_OVER_RETURNSTACK
#define JITTER_OVER_RETURNSTACK()  \
  JITTER_STACK_NTOS_OVER (jitterlisp_object,  \
    jitter_state_runtime. /* not an error */,  \
    returnstack  \
    )
/* Wrapper definition of the tuck operation for the
   non-TOS-optimized stack "returnstack". */
#undef JITTER_TUCK_RETURNSTACK
#undef JITTERLISPVM_TUCK_RETURNSTACK
#define JITTERLISPVM_TUCK_RETURNSTACK /* The preferred name. */ \
  JITTER_TUCK_RETURNSTACK
#define JITTER_TUCK_RETURNSTACK()  \
  JITTER_STACK_NTOS_TUCK (jitterlisp_object,  \
    jitter_state_runtime. /* not an error */,  \
    returnstack  \
    )
/* Wrapper definition of the nip operation for the
   non-TOS-optimized stack "returnstack". */
#undef JITTER_NIP_RETURNSTACK
#undef JITTERLISPVM_NIP_RETURNSTACK
#define JITTERLISPVM_NIP_RETURNSTACK /* The preferred name. */ \
  JITTER_NIP_RETURNSTACK
#define JITTER_NIP_RETURNSTACK()  \
  JITTER_STACK_NTOS_NIP (jitterlisp_object,  \
    jitter_state_runtime. /* not an error */,  \
    returnstack  \
    )
/* Wrapper definition of the rot operation for the
   non-TOS-optimized stack "returnstack". */
#undef JITTER_ROT_RETURNSTACK
#undef JITTERLISPVM_ROT_RETURNSTACK
#define JITTERLISPVM_ROT_RETURNSTACK /* The preferred name. */ \
  JITTER_ROT_RETURNSTACK
#define JITTER_ROT_RETURNSTACK()  \
  JITTER_STACK_NTOS_ROT (jitterlisp_object,  \
    jitter_state_runtime. /* not an error */,  \
    returnstack  \
    )
/* Wrapper definition of the mrot operation for the
   non-TOS-optimized stack "returnstack". */
#undef JITTER_MROT_RETURNSTACK
#undef JITTERLISPVM_MROT_RETURNSTACK
#define JITTERLISPVM_MROT_RETURNSTACK /* The preferred name. */ \
  JITTER_MROT_RETURNSTACK
#define JITTER_MROT_RETURNSTACK()  \
  JITTER_STACK_NTOS_MROT (jitterlisp_object,  \
    jitter_state_runtime. /* not an error */,  \
    returnstack  \
    )
/* Wrapper definition of the roll operation for the
   non-TOS-optimized stack "returnstack". */
#undef JITTER_ROLL_RETURNSTACK
#undef JITTERLISPVM_ROLL_RETURNSTACK
#define JITTERLISPVM_ROLL_RETURNSTACK /* The preferred name. */ \
  JITTER_ROLL_RETURNSTACK
#define JITTER_ROLL_RETURNSTACK(x0)  \
  JITTER_STACK_NTOS_ROLL (jitterlisp_object,  \
    jitter_state_runtime. /* not an error */,  \
    returnstack  \
    , x0)
/* Wrapper definition of the mroll operation for the
   non-TOS-optimized stack "returnstack". */
#undef JITTER_MROLL_RETURNSTACK
#undef JITTERLISPVM_MROLL_RETURNSTACK
#define JITTERLISPVM_MROLL_RETURNSTACK /* The preferred name. */ \
  JITTER_MROLL_RETURNSTACK
#define JITTER_MROLL_RETURNSTACK(x0)  \
  JITTER_STACK_NTOS_MROLL (jitterlisp_object,  \
    jitter_state_runtime. /* not an error */,  \
    returnstack  \
    , x0)
/* Wrapper definition of the slide operation for the
   non-TOS-optimized stack "returnstack". */
#undef JITTER_SLIDE_RETURNSTACK
#undef JITTERLISPVM_SLIDE_RETURNSTACK
#define JITTERLISPVM_SLIDE_RETURNSTACK /* The preferred name. */ \
  JITTER_SLIDE_RETURNSTACK
#define JITTER_SLIDE_RETURNSTACK(x0, x1)  \
  JITTER_STACK_NTOS_SLIDE (jitterlisp_object,  \
    jitter_state_runtime. /* not an error */,  \
    returnstack  \
    , x0, x1)
/* Wrapper definition of the whirl operation for the
   non-TOS-optimized stack "returnstack". */
#undef JITTER_WHIRL_RETURNSTACK
#undef JITTERLISPVM_WHIRL_RETURNSTACK
#define JITTERLISPVM_WHIRL_RETURNSTACK /* The preferred name. */ \
  JITTER_WHIRL_RETURNSTACK
#define JITTER_WHIRL_RETURNSTACK(x0)  \
  JITTER_STACK_NTOS_WHIRL (jitterlisp_object,  \
    jitter_state_runtime. /* not an error */,  \
    returnstack  \
    , x0)
/* Wrapper definition of the bulge operation for the
   non-TOS-optimized stack "returnstack". */
#undef JITTER_BULGE_RETURNSTACK
#undef JITTERLISPVM_BULGE_RETURNSTACK
#define JITTERLISPVM_BULGE_RETURNSTACK /* The preferred name. */ \
  JITTER_BULGE_RETURNSTACK
#define JITTER_BULGE_RETURNSTACK(x0)  \
  JITTER_STACK_NTOS_BULGE (jitterlisp_object,  \
    jitter_state_runtime. /* not an error */,  \
    returnstack  \
    , x0)
/* Wrapper definition of the height operation for the
   non-TOS-optimized stack "returnstack". */
#undef JITTER_HEIGHT_RETURNSTACK
#undef JITTERLISPVM_HEIGHT_RETURNSTACK
#define JITTERLISPVM_HEIGHT_RETURNSTACK /* The preferred name. */ \
  JITTER_HEIGHT_RETURNSTACK
#define JITTER_HEIGHT_RETURNSTACK()  \
  JITTER_STACK_NTOS_HEIGHT (jitterlisp_object,  \
    jitter_state_runtime. /* not an error */,  \
    returnstack  \
    )
/* Wrapper definition of the set_height operation for the
   non-TOS-optimized stack "returnstack". */
#undef JITTER_SET_HEIGHT_RETURNSTACK
#undef JITTERLISPVM_SET_HEIGHT_RETURNSTACK
#define JITTERLISPVM_SET_HEIGHT_RETURNSTACK /* The preferred name. */ \
  JITTER_SET_HEIGHT_RETURNSTACK
#define JITTER_SET_HEIGHT_RETURNSTACK(x0)  \
  JITTER_STACK_NTOS_SET_HEIGHT (jitterlisp_object,  \
    jitter_state_runtime. /* not an error */,  \
    returnstack  \
    , x0)
/* Wrapper definition of the reverse operation for the
   non-TOS-optimized stack "returnstack". */
#undef JITTER_REVERSE_RETURNSTACK
#undef JITTERLISPVM_REVERSE_RETURNSTACK
#define JITTERLISPVM_REVERSE_RETURNSTACK /* The preferred name. */ \
  JITTER_REVERSE_RETURNSTACK
#define JITTER_REVERSE_RETURNSTACK(x0)  \
  JITTER_STACK_NTOS_REVERSE (jitterlisp_object,  \
    jitter_state_runtime. /* not an error */,  \
    returnstack  \
    , x0)
/* Wrapper definition of the unary operation for the
   non-TOS-optimized stack "returnstack". */
#undef JITTER_UNARY_RETURNSTACK
#undef JITTERLISPVM_UNARY_RETURNSTACK
#define JITTERLISPVM_UNARY_RETURNSTACK /* The preferred name. */ \
  JITTER_UNARY_RETURNSTACK
#define JITTER_UNARY_RETURNSTACK(x0)  \
  JITTER_STACK_NTOS_UNARY (jitterlisp_object,  \
    jitter_state_runtime. /* not an error */,  \
    returnstack  \
    , x0)
/* Wrapper definition of the binary operation for the
   non-TOS-optimized stack "returnstack". */
#undef JITTER_BINARY_RETURNSTACK
#undef JITTERLISPVM_BINARY_RETURNSTACK
#define JITTERLISPVM_BINARY_RETURNSTACK /* The preferred name. */ \
  JITTER_BINARY_RETURNSTACK
#define JITTER_BINARY_RETURNSTACK(x0)  \
  JITTER_STACK_NTOS_BINARY (jitterlisp_object,  \
    jitter_state_runtime. /* not an error */,  \
    returnstack  \
    , x0)

/* Late C code from the user. */

__attribute__ ((unused))
void
debug_pointer (jitter_int index, const void *pointer)
{
  return;
  printf ("[DEBUG: %lli %p]\n", (long long) index, pointer);
  fflush (stdout);
}

/* Open an argument-type-checking sequence, for the given number of arguments
   to be read from the main stack.  This is a helper macro for
   JITTERLISPVM_CHECK_TYPES_* . */
#define JITTERLISPVM_BEGIN_CHECK_TYPES_(_jitterlisp_vm_in_arity)  \
  JITTER_BEGIN_                                                   \
    int _jitterlispvm_arg_no = (_jitterlisp_vm_in_arity);         \
    int _jitterlispvm_arg_index __attribute__ ((unused)) = 0;     \
    int _jitterlispvm_arg_depth __attribute__ ((unused)) \
      = _jitterlispvm_arg_no - 1;

/* Check the next argument in the sequence, failing if its type doesn't match
   the given uppercase suffix.  Do nothing if compiling an unsafe JitterLisp. */
#ifdef JITTERLISP_UNSAFE
# define JITTERLISPVM_CHECK_NEXT_TYPE_(_jitterlisp_uppercase_type,    \
                                       _jitterlisp_error_fast_label)  \
    { /* Do nothing. */ }
#else
# define JITTERLISPVM_CHECK_NEXT_TYPE_(_jitterlisp_uppercase_type,     \
                                       _jitterlisp_error_fast_label)   \
    {                                                                  \
      /* Branch-fast to the given label if the next object type is     \
         not the required one. */                                      \
      JITTER_CONCATENATE_TWO (JITTERLISP_BRANCH_FAST_UNLESS_,          \
                              _jitterlisp_uppercase_type)              \
         (JITTER_AT_DEPTH_MAINSTACK(_jitterlispvm_arg_depth),          \
          _jitterlisp_error_fast_label);                               \
      _jitterlispvm_arg_depth --;                                      \
      _jitterlispvm_arg_index ++;                                      \
    }
#endif // #ifdef JITTERLISP_UNSAFE

/* Close an argument-type-checking sequence.  This is a helper macro for
   JITTERLISPVM_CHECK_TYPES_* . */
#define JITTERLISPVM_END_CHECK_TYPES_  \
  JITTER_END_

/* For in-arity N, check that the topmost N arguments have the given N types
   expressed as uppercase suffixes, respectively.  This functionality is
   provided for a few common values of N . */
#define JITTERLISPVM_CHECK_TYPES_1(_jitterlisp_uppercase_type_0,  \
                                   _jitterlisp_error_fast_label)  \
  JITTERLISPVM_BEGIN_CHECK_TYPES_(1)                              \
    JITTERLISPVM_CHECK_NEXT_TYPE_(_jitterlisp_uppercase_type_0,   \
                                  _jitterlisp_error_fast_label);  \
  JITTERLISPVM_END_CHECK_TYPES_
#define JITTERLISPVM_CHECK_TYPES_2(_jitterlisp_uppercase_type_0,  \
                                   _jitterlisp_uppercase_type_1,  \
                                   _jitterlisp_error_fast_label)  \
  JITTERLISPVM_BEGIN_CHECK_TYPES_(2)                              \
    JITTERLISPVM_CHECK_NEXT_TYPE_(_jitterlisp_uppercase_type_0,   \
                                  _jitterlisp_error_fast_label);  \
    JITTERLISPVM_CHECK_NEXT_TYPE_(_jitterlisp_uppercase_type_1,   \
                                  _jitterlisp_error_fast_label);  \
  JITTERLISPVM_END_CHECK_TYPES_
#define JITTERLISPVM_CHECK_TYPES_3(_jitterlisp_uppercase_type_0,  \
                                   _jitterlisp_uppercase_type_1,  \
                                   _jitterlisp_uppercase_type_2,  \
                                   _jitterlisp_error_fast_label)  \
  JITTERLISPVM_BEGIN_CHECK_TYPES_(3)                              \
    JITTERLISPVM_CHECK_NEXT_TYPE_(_jitterlisp_uppercase_type_0,   \
                                  _jitterlisp_error_fast_label);  \
    JITTERLISPVM_CHECK_NEXT_TYPE_(_jitterlisp_uppercase_type_1,   \
                                  _jitterlisp_error_fast_label);  \
    JITTERLISPVM_CHECK_NEXT_TYPE_(_jitterlisp_uppercase_type_2,   \
                                  _jitterlisp_error_fast_label);  \
  JITTERLISPVM_END_CHECK_TYPES_
#define JITTERLISPVM_CHECK_TYPES_4(_jitterlisp_uppercase_type_0,  \
                                   _jitterlisp_uppercase_type_1,  \
                                   _jitterlisp_uppercase_type_2,  \
                                   _jitterlisp_uppercase_type_3,  \
                                   _jitterlisp_error_fast_label)  \
  JITTERLISPVM_BEGIN_CHECK_TYPES_(4)                              \
    JITTERLISPVM_CHECK_NEXT_TYPE_(_jitterlisp_uppercase_type_0,   \
                                  _jitterlisp_error_fast_label);  \
    JITTERLISPVM_CHECK_NEXT_TYPE_(_jitterlisp_uppercase_type_1,   \
                                  _jitterlisp_error_fast_label);  \
    JITTERLISPVM_CHECK_NEXT_TYPE_(_jitterlisp_uppercase_type_2,   \
                                  _jitterlisp_error_fast_label);  \
    JITTERLISPVM_CHECK_NEXT_TYPE_(_jitterlisp_uppercase_type_3,   \
                                  _jitterlisp_error_fast_label);  \
  JITTERLISPVM_END_CHECK_TYPES_

#if 0
# define JITTERLISPVM_ERROR_INVALID_PRIMITIVE_ARGUMENT_TYPE_          \
    jitterlispvm_error_invalid_primitive_argument_type_unfriendly ()
#else
# define JITTERLISPVM_ERROR_INVALID_PRIMITIVE_ARGUMENT_TYPE_     \
    jitterlispvm_error_invalid_primitive_argument_type_friendly  \
       (JITTER_SPECIALIZED_INSTRUCTION_OPCODE,                   \
        _jitterlispvm_arg_index,                                 \
        JITTER_AT_DEPTH_MAINSTACK(_jitterlispvm_arg_depth))
#endif


// Unfortunately the attribute is invisible across the wrapper.
// This is convenient for debugging, but I don't want to use it in production:
// passing parameters at every call makes the code much bigger, even if the
// call is not executed.
__attribute__ ((noreturn, unused))
static void
jitterlispvm_error_invalid_primitive_argument_type_friendly
   (int sins_opcode,
    int arg_index,
    jitterlisp_object o)
{
  /* Print information about the argument and its hex representation:
     don't dare yet to print it as a Lisp object, as the printer might
     crash if there is a bug and the object is invalid. */
#define SIZEOF_BUFFER 1000
  char buffer [SIZEOF_BUFFER];
  snprintf (buffer,
            SIZEOF_BUFFER,
            "%s: About the %i-th (0-based) primitive argument %p\n",
            jitterlispvm_specialized_instruction_names [sins_opcode],
            arg_index, (void *) o);
#undef SIZEOF_BUFFER
  jitterlisp_print_error_char_star (buffer);

  /* This shouldn't be needed on GNU, but flush the output so that we can be
     sure that the previous line is visible before we crash. */
  jitter_print_flush (jitterlisp_print_context);

  /* Okay, now we can print in in Lisp. */
  jitterlisp_print_error_char_star ("  (in Lisp ");
  jitterlisp_print_error (o);
  jitterlisp_print_error_char_star ("):\n");

  jitterlisp_error_cloned ("invalid primitive argument type");
}

__attribute__ ((noreturn, unused))
static void
jitterlispvm_error_invalid_primitive_argument_type_unfriendly (void)
{
  jitterlisp_error_cloned ("invalid primitive argument type");
}

static void
jitterlisp_fail_from_vm (void)
{
  jitterlisp_error_cloned ("unspecified error raised by VM code");
}

    static const char *stack_printf_format_string __attribute__ ((unused))
      = "%" JITTER_PRIi "\n";
  
  
  /* End of the late C code from the user. */

/* The definition of this is machine-generated in jitterlispvm-vm2.c , and the
   function is not intended for the user.  If initializing then set
   structuredvm_threads and structuredvm_thread_sizes and just return, ignoring
   the other fields and s.  If not initializing then actually enter VM code
   starting from the initial program point in the state. */
static enum jitterlispvm_exit_status
jitterlispvm_execute_or_initialize (bool jitter_initialize,
                                struct jitterlispvm_state * const jitter_original_state)
  __attribute__ ((noclone, noinline, no_reorder));

enum jitterlispvm_exit_status
jitterlispvm_execute_executable_routine (const struct jitter_executable_routine *er,
                                     struct jitterlispvm_state *s)
{
  jitterlispvm_make_place_for_slow_registers (s, er->slow_register_per_class_no);
  jitter_program_point initial_program_point
    = JITTERLISPVM_EXECUTABLE_ROUTINE_BEGINNING (er);
  return jitterlispvm_branch_to_program_point (initial_program_point,
                                           s);
}


/* Threads or pointers to native code blocks of course don't exist with
   switch-dispatching. */
#ifndef JITTER_DISPATCH_SWITCH
const jitter_thread *
jitterlispvm_threads;

const jitter_thread *
jitterlispvm_thread_ends;

const long *
jitterlispvm_thread_sizes;
#endif // #ifndef JITTER_DISPATCH_SWITCH

void
jitterlispvm_initialize_threads (void)
{
  jitterlispvm_execute_or_initialize (true, NULL);
}

enum jitterlispvm_exit_status
jitterlispvm_branch_to_program_point (jitterlispvm_program_point p, struct jitterlispvm_state *s)
{
  /* Change the state to set the initial program point. */
  s->jitterlispvm_state_backing.initial_program_point = p;

  /* Execute. */
  return jitterlispvm_execute_or_initialize (false, s);
}

__attribute__ ((noinline, noclone, no_reorder))
void
jitterlispvm_asm_headers (void)
{
#ifdef JITTER_HAVE_PATCH_IN
  /* Generate the single patch-in header for this executor as a
     global asm statement.  This expands into a global definition in
     assembly in a separate subsection, and relies on toplevel C
     definitions not being reordered: jitterlispvm_execute_or_initialize
     will add to the same global.  Do the same for defects. */
  JITTER_PATCH_IN_HEADER(jitterlispvm);
#endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_HAVE_DEFECT_REPLACEMENT

  /* The same for defects... */
  JITTER_DEFECT_HEADER(jitterlispvm);
#endif // #ifdef JITTER_HAVE_DEFECT_REPLACEMENT

#ifndef JITTER_DISPATCH_SWITCH
  JITTER_DATA_LOCATION_HEADER(jitterlispvm);
#endif // #ifndef JITTER_DISPATCH_SWITCH

}
static enum jitterlispvm_exit_status
jitterlispvm_execute_or_initialize (bool jitter_initialize,
                                struct jitterlispvm_state * const jitter_original_state)
{
/* Undefine the state field access macros which are meant to be
   used out of VM instructions. */
#undef JITTERLISPVM_STATE_RUNTIME_FIELD
#undef JITTERLISPVM_STATE_BACKING_FIELD

/* Replace the definitions by versions which will work (only!)
   inside instruction bodies.  These macros have one argument
   instead of two: the VM state being used is *the* current
   state. */
#define JITTERLISPVM_STATE_RUNTIME_FIELD  _JITTER_STATE_RUNTIME_FIELD
#define JITTERLISPVM_STATE_BACKING_FIELD  _JITTER_STATE_BACKING_FIELD

#ifdef JITTER_DISPATCH_NO_THREADING
  /* Save the values in the registers we reserved as global variables,
     since from the point of view of the other C compilation units such
     registers are callee-save.  FIXME: this is not really needed when
     initializing, if I've been careful; but for the time being I want
     to play it safe. */
  union jitter_word jitter_register_buffer [JITTERLISPVM_REGISTER_BUFFER_ELEMENT_NO];
  jitterlispvm_save_registers (jitter_register_buffer);
#endif // #ifdef JITTER_DISPATCH_NO_THREADING

  /* Initialization.  This is only called once at startup. */
  if (__builtin_expect (jitter_initialize, false))
    {
      /* Make sure that vm1 and vm2 were macroexpanded consistently
         with respect to instrumentation macros.  This relies on the
         enum values for each feature working as individual bits in a
         bitmask: see the comment in jitter/jitter-vm.h . */
      enum jitter_vm_instrumentation correct_instrumentation
        = jitter_vm_instrumentation_none;
#if defined (JITTERLISPVM_PROFILE_COUNT)
      correct_instrumentation |= jitter_vm_instrumentation_count;
#endif
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
      correct_instrumentation |= jitter_vm_instrumentation_sample;
#endif
      if (jitterlispvm_vm_configuration->instrumentation != correct_instrumentation)
        jitter_fatal ("vm1 and vm2 were compiled with different profiling "
                      "instrumentation macros.  Please recompile with coherent "
                      "CPPFLAGS");

#if defined (JITTERLISPVM_PROFILE_SAMPLE)
    /* Initialise the sample-profile subsystem, once and for all. */
    jitterlispvm_profile_sample_initialize ();
#endif // #if defined (JITTERLISPVM_PROFILE_SAMPLE)

#ifndef JITTER_DISPATCH_SWITCH
      /* FIXME: I can do this with only one relocation, by keeping
         a pointer to the first VM instruction beginning in a static
         variable, and then having a static vector of offsets with
         respect to the first pointer.  This will slightly complicate
         my initialization code, but should make startup faster.
         FIXME: that won't work on AVR, according to the GCC
         documentation.  Do I care?  Probably not, since AVRs can't
         address more than 2^16 bytes, which is too little to run my
         VMs. */
      static const jitter_thread jitterlispvm_the_threads []
        = {
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eINVALID),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eBEGINBASICBLOCK),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eEXITVM),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eDATALOCATIONS),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eNOP),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eUNREACHABLE0),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eUNREACHABLE1),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_ePRETENDTOJUMPANYWHERE),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(at_mdepth_mto_mregister__n1___rrR),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(at_mdepth_mto_mregister__n2___rrR),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(at_mdepth_mto_mregister__n3___rrR),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(at_mdepth_mto_mregister__n4___rrR),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(at_mdepth_mto_mregister__n5___rrR),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(at_mdepth_mto_mregister__n6___rrR),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(at_mdepth_mto_mregister__n7___rrR),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(at_mdepth_mto_mregister__n8___rrR),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(at_mdepth_mto_mregister__n9___rrR),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(at_mdepth_mto_mregister__n10___rrR),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(at_mdepth_mto_mregister__nR___rrR),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(branch__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(branch_mif_mfalse__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(branch_mif_mnon_mpositive__fR__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(branch_mif_mnot_mless__fR__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(branch_mif_mnot_mnull__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(branch_mif_mnull__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(branch_mif_mpositive__fR__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(branch_mif_mregister_mnon_mpositive___rrR__fR__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(branch_mif_mregister_mnon_mzero___rrR__fR__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(branch_mif_mregister_mnot_mnull___rrR__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(branch_mif_mregister_mnull___rrR__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(branch_mif_mregister_mpositive___rrR__fR__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(branch_mif_mtrue__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(call__n0__retR),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(call__n1__retR),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(call__n2__retR),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(call__n3__retR),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(call__n4__retR),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(call__n5__retR),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(call__n6__retR),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(call__n7__retR),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(call__n8__retR),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(call__n9__retR),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(call__n10__retR),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(call__nR__retR),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(call_mcompiled__n0__retR),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(call_mcompiled__n1__retR),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(call_mcompiled__n2__retR),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(call_mcompiled__n3__retR),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(call_mcompiled__n4__retR),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(call_mcompiled__n5__retR),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(call_mcompiled__n6__retR),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(call_mcompiled__n7__retR),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(call_mcompiled__n8__retR),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(call_mcompiled__n9__retR),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(call_mcompiled__n10__retR),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(call_mcompiled__nR__retR),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(call_mfrom_mc__retR),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(canonicalize_mboolean),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(cdr_mregister___rrR___rrR__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(check_mclosure__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(check_mglobal_mdefined__nR__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(check_min_marity__n0__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(check_min_marity__n1__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(check_min_marity__n2__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(check_min_marity__n3__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(check_min_marity__n4__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(check_min_marity__n5__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(check_min_marity__n6__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(check_min_marity__n7__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(check_min_marity__n8__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(check_min_marity__n9__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(check_min_marity__n10__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(check_min_marity__nR__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(check_min_marity_m_malt__n0__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(check_min_marity_m_malt__n1__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(check_min_marity_m_malt__n2__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(check_min_marity_m_malt__n3__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(check_min_marity_m_malt__n4__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(check_min_marity_m_malt__n5__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(check_min_marity_m_malt__n6__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(check_min_marity_m_malt__n7__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(check_min_marity_m_malt__n8__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(check_min_marity_m_malt__n9__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(check_min_marity_m_malt__n10__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(check_min_marity_m_malt__nR__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(copy_mfrom_mliteral__nR),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(copy_mfrom_mregister___rrR),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(copy_mto_mregister___rrR),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(drop),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(drop_mnip),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(dup),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(exitvm),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(fail__retR),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(gc_mif_mneeded__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(heap_mallocate__n4),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(heap_mallocate__n8),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(heap_mallocate__n12),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(heap_mallocate__n16),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(heap_mallocate__n24),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(heap_mallocate__n32),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(heap_mallocate__n36),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(heap_mallocate__n48),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(heap_mallocate__n52),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(heap_mallocate__n64),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(heap_mallocate__nR),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(literal_mto_mregister__nR___rrR),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(nip),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(nip_mdrop),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(nip_mfive),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(nip_mfive_mdrop),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(nip_mfour),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(nip_mfour_mdrop),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(nip_mpush_mliteral__nR),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(nip_mpush_mregister___rrR),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(nip_msix),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(nip_msix_mdrop),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(nip_mthree),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(nip_mthree_mdrop),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(nip_mtwo),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(nip_mtwo_mdrop),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(nop),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(one_mminus_mregister___rrR___rrR__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(one_mplus_mregister___rrR___rrR__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(pop_mto_mglobal__nR__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(pop_mto_mglobal_mdefined__nR__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(pop_mto_mregister___rrR),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive__nR__n0__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive__nR__n1__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive__nR__n2__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive__nR__n3__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive__nR__n4__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive__nR__nR__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mboolean_mcanonicalize),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mbox),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mbox_mget__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mbox_msetb_mspecial__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mcar__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mcdr__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mcharacterp),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mcons_mspecial),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mconsp),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_meqp),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mfixnum_meqp__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mfixnum_mnot_meqp__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mfixnump),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mgreaterp__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mlessp__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mnegate__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mnegativep__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mnon_mconsp),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mnon_mnegativep__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mnon_mnullp),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mnon_mpositivep__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mnon_msymbolp),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mnon_mzerop__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mnot),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mnot_meqp),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mnot_mgreaterp__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mnot_mlessp__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mnothingp),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mnullp),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mone_mminus__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mone_mplus__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mpositivep__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mprimordial_mdivided__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mprimordial_mdivided_munsafe__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mprimordial_mminus__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mprimordial_mplus__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mprimordial_mtimes__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mquotient__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mquotient_munsafe__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mremainder__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mremainder_munsafe__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mset_mcarb_mspecial__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mset_mcdrb_mspecial__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_msymbolp),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mtwo_mdivided__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mtwo_mquotient__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mtwo_mremainder__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mtwo_mtimes__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_muniquep),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mzerop__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(procedure_mprolog),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(push_mfalse),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(push_mglobal__nR__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(push_mliteral__nR),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(push_mnil),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(push_mnothing),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(push_mone),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(push_mregister___rrR),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(push_munspecified),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(push_mzero),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(register_mto_mregister___rrR___rrR),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(restore_mregister___rrR),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(return),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(save_mregister___rrR),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(tail_mcall__n0__retR),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(tail_mcall__n1__retR),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(tail_mcall__n2__retR),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(tail_mcall__n3__retR),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(tail_mcall__n4__retR),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(tail_mcall__n5__retR),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(tail_mcall__n6__retR),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(tail_mcall__n7__retR),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(tail_mcall__n8__retR),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(tail_mcall__n9__retR),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(tail_mcall__n10__retR),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(tail_mcall__nR__retR),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(tail_mcall_mcompiled__n0__retR),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(tail_mcall_mcompiled__n1__retR),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(tail_mcall_mcompiled__n2__retR),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(tail_mcall_mcompiled__n3__retR),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(tail_mcall_mcompiled__n4__retR),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(tail_mcall_mcompiled__n5__retR),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(tail_mcall_mcompiled__n6__retR),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(tail_mcall_mcompiled__n7__retR),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(tail_mcall_mcompiled__n8__retR),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(tail_mcall_mcompiled__n9__retR),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(tail_mcall_mcompiled__n10__retR),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(tail_mcall_mcompiled__nR__retR),
            && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(unreachable),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eREPLACEMENT_mbranch__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eREPLACEMENT_mbranch_mif_mfalse__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eREPLACEMENT_mbranch_mif_mnon_mpositive__fR__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eREPLACEMENT_mbranch_mif_mnot_mless__fR__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eREPLACEMENT_mbranch_mif_mnot_mnull__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eREPLACEMENT_mbranch_mif_mnull__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eREPLACEMENT_mbranch_mif_mpositive__fR__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eREPLACEMENT_mbranch_mif_mregister_mnon_mpositive___rrR__fR__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eREPLACEMENT_mbranch_mif_mregister_mnon_mzero___rrR__fR__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eREPLACEMENT_mbranch_mif_mregister_mnot_mnull___rrR__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eREPLACEMENT_mbranch_mif_mregister_mnull___rrR__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eREPLACEMENT_mbranch_mif_mregister_mpositive___rrR__fR__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eREPLACEMENT_mbranch_mif_mtrue__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eREPLACEMENT_mcall__n0__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eREPLACEMENT_mcall__n1__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eREPLACEMENT_mcall__n2__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eREPLACEMENT_mcall__n3__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eREPLACEMENT_mcall__n4__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eREPLACEMENT_mcall__n5__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eREPLACEMENT_mcall__n6__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eREPLACEMENT_mcall__n7__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eREPLACEMENT_mcall__n8__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eREPLACEMENT_mcall__n9__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eREPLACEMENT_mcall__n10__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eREPLACEMENT_mcall__nR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eREPLACEMENT_mcall_mcompiled__n0__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eREPLACEMENT_mcall_mcompiled__n1__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eREPLACEMENT_mcall_mcompiled__n2__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eREPLACEMENT_mcall_mcompiled__n3__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eREPLACEMENT_mcall_mcompiled__n4__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eREPLACEMENT_mcall_mcompiled__n5__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eREPLACEMENT_mcall_mcompiled__n6__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eREPLACEMENT_mcall_mcompiled__n7__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eREPLACEMENT_mcall_mcompiled__n8__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eREPLACEMENT_mcall_mcompiled__n9__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eREPLACEMENT_mcall_mcompiled__n10__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eREPLACEMENT_mcall_mcompiled__nR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eREPLACEMENT_mcall_mfrom_mc__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eREPLACEMENT_mcdr_mregister___rrR___rrR__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eREPLACEMENT_mcheck_mclosure__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eREPLACEMENT_mcheck_mglobal_mdefined__nR__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eREPLACEMENT_mcheck_min_marity__n0__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eREPLACEMENT_mcheck_min_marity__n1__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eREPLACEMENT_mcheck_min_marity__n2__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eREPLACEMENT_mcheck_min_marity__n3__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eREPLACEMENT_mcheck_min_marity__n4__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eREPLACEMENT_mcheck_min_marity__n5__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eREPLACEMENT_mcheck_min_marity__n6__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eREPLACEMENT_mcheck_min_marity__n7__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eREPLACEMENT_mcheck_min_marity__n8__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eREPLACEMENT_mcheck_min_marity__n9__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eREPLACEMENT_mcheck_min_marity__n10__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eREPLACEMENT_mcheck_min_marity__nR__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eREPLACEMENT_mcheck_min_marity_m_malt__n0__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eREPLACEMENT_mcheck_min_marity_m_malt__n1__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eREPLACEMENT_mcheck_min_marity_m_malt__n2__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eREPLACEMENT_mcheck_min_marity_m_malt__n3__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eREPLACEMENT_mcheck_min_marity_m_malt__n4__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eREPLACEMENT_mcheck_min_marity_m_malt__n5__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eREPLACEMENT_mcheck_min_marity_m_malt__n6__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eREPLACEMENT_mcheck_min_marity_m_malt__n7__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eREPLACEMENT_mcheck_min_marity_m_malt__n8__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eREPLACEMENT_mcheck_min_marity_m_malt__n9__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eREPLACEMENT_mcheck_min_marity_m_malt__n10__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eREPLACEMENT_mcheck_min_marity_m_malt__nR__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eREPLACEMENT_mexitvm__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eREPLACEMENT_mgc_mif_mneeded__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eREPLACEMENT_mone_mminus_mregister___rrR___rrR__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eREPLACEMENT_mone_mplus_mregister___rrR___rrR__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eREPLACEMENT_mpop_mto_mglobal__nR__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eREPLACEMENT_mpop_mto_mglobal_mdefined__nR__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eREPLACEMENT_mprimitive__nR__n0__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eREPLACEMENT_mprimitive__nR__n1__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eREPLACEMENT_mprimitive__nR__n2__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eREPLACEMENT_mprimitive__nR__n3__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eREPLACEMENT_mprimitive__nR__n4__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eREPLACEMENT_mprimitive__nR__nR__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eREPLACEMENT_mprimitive_mbox_mget__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eREPLACEMENT_mprimitive_mbox_msetb_mspecial__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eREPLACEMENT_mprimitive_mcar__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eREPLACEMENT_mprimitive_mcdr__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eREPLACEMENT_mprimitive_mfixnum_meqp__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eREPLACEMENT_mprimitive_mfixnum_mnot_meqp__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eREPLACEMENT_mprimitive_mgreaterp__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eREPLACEMENT_mprimitive_mlessp__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eREPLACEMENT_mprimitive_mnegate__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eREPLACEMENT_mprimitive_mnegativep__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eREPLACEMENT_mprimitive_mnon_mnegativep__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eREPLACEMENT_mprimitive_mnon_mpositivep__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eREPLACEMENT_mprimitive_mnon_mzerop__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eREPLACEMENT_mprimitive_mnot_mgreaterp__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eREPLACEMENT_mprimitive_mnot_mlessp__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eREPLACEMENT_mprimitive_mone_mminus__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eREPLACEMENT_mprimitive_mone_mplus__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eREPLACEMENT_mprimitive_mpositivep__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eREPLACEMENT_mprimitive_mprimordial_mdivided__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eREPLACEMENT_mprimitive_mprimordial_mdivided_munsafe__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eREPLACEMENT_mprimitive_mprimordial_mminus__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eREPLACEMENT_mprimitive_mprimordial_mplus__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eREPLACEMENT_mprimitive_mprimordial_mtimes__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eREPLACEMENT_mprimitive_mquotient__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eREPLACEMENT_mprimitive_mquotient_munsafe__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eREPLACEMENT_mprimitive_mremainder__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eREPLACEMENT_mprimitive_mremainder_munsafe__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eREPLACEMENT_mprimitive_mset_mcarb_mspecial__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eREPLACEMENT_mprimitive_mset_mcdrb_mspecial__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eREPLACEMENT_mprimitive_mtwo_mdivided__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eREPLACEMENT_mprimitive_mtwo_mquotient__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eREPLACEMENT_mprimitive_mtwo_mremainder__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eREPLACEMENT_mprimitive_mtwo_mtimes__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eREPLACEMENT_mprimitive_mzerop__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eREPLACEMENT_mprocedure_mprolog__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eREPLACEMENT_mpush_mglobal__nR__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eREPLACEMENT_mreturn__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eREPLACEMENT_mtail_mcall__n0__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eREPLACEMENT_mtail_mcall__n1__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eREPLACEMENT_mtail_mcall__n2__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eREPLACEMENT_mtail_mcall__n3__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eREPLACEMENT_mtail_mcall__n4__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eREPLACEMENT_mtail_mcall__n5__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eREPLACEMENT_mtail_mcall__n6__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eREPLACEMENT_mtail_mcall__n7__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eREPLACEMENT_mtail_mcall__n8__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eREPLACEMENT_mtail_mcall__n9__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eREPLACEMENT_mtail_mcall__n10__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eREPLACEMENT_mtail_mcall__nR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eREPLACEMENT_mtail_mcall_mcompiled__n0__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eREPLACEMENT_mtail_mcall_mcompiled__n1__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eREPLACEMENT_mtail_mcall_mcompiled__n2__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eREPLACEMENT_mtail_mcall_mcompiled__n3__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eREPLACEMENT_mtail_mcall_mcompiled__n4__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eREPLACEMENT_mtail_mcall_mcompiled__n5__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eREPLACEMENT_mtail_mcall_mcompiled__n6__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eREPLACEMENT_mtail_mcall_mcompiled__n7__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eREPLACEMENT_mtail_mcall_mcompiled__n8__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eREPLACEMENT_mtail_mcall_mcompiled__n9__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eREPLACEMENT_mtail_mcall_mcompiled__n10__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eREPLACEMENT_mtail_mcall_mcompiled__nR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eREPLACEMENT_munreachable__retR),
                0)
          };
      static const jitter_thread jitterlispvm_the_thread_ends []
        = {
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eINVALID),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eBEGINBASICBLOCK),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eEXITVM),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eDATALOCATIONS),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eNOP),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eUNREACHABLE0),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eUNREACHABLE1),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_ePRETENDTOJUMPANYWHERE),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(at_mdepth_mto_mregister__n1___rrR),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(at_mdepth_mto_mregister__n2___rrR),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(at_mdepth_mto_mregister__n3___rrR),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(at_mdepth_mto_mregister__n4___rrR),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(at_mdepth_mto_mregister__n5___rrR),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(at_mdepth_mto_mregister__n6___rrR),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(at_mdepth_mto_mregister__n7___rrR),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(at_mdepth_mto_mregister__n8___rrR),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(at_mdepth_mto_mregister__n9___rrR),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(at_mdepth_mto_mregister__n10___rrR),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(at_mdepth_mto_mregister__nR___rrR),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(branch__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(branch_mif_mfalse__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(branch_mif_mnon_mpositive__fR__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(branch_mif_mnot_mless__fR__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(branch_mif_mnot_mnull__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(branch_mif_mnull__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(branch_mif_mpositive__fR__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(branch_mif_mregister_mnon_mpositive___rrR__fR__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(branch_mif_mregister_mnon_mzero___rrR__fR__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(branch_mif_mregister_mnot_mnull___rrR__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(branch_mif_mregister_mnull___rrR__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(branch_mif_mregister_mpositive___rrR__fR__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(branch_mif_mtrue__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(call__n0__retR),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(call__n1__retR),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(call__n2__retR),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(call__n3__retR),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(call__n4__retR),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(call__n5__retR),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(call__n6__retR),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(call__n7__retR),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(call__n8__retR),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(call__n9__retR),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(call__n10__retR),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(call__nR__retR),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(call_mcompiled__n0__retR),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(call_mcompiled__n1__retR),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(call_mcompiled__n2__retR),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(call_mcompiled__n3__retR),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(call_mcompiled__n4__retR),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(call_mcompiled__n5__retR),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(call_mcompiled__n6__retR),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(call_mcompiled__n7__retR),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(call_mcompiled__n8__retR),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(call_mcompiled__n9__retR),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(call_mcompiled__n10__retR),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(call_mcompiled__nR__retR),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(call_mfrom_mc__retR),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(canonicalize_mboolean),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(cdr_mregister___rrR___rrR__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(check_mclosure__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(check_mglobal_mdefined__nR__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(check_min_marity__n0__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(check_min_marity__n1__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(check_min_marity__n2__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(check_min_marity__n3__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(check_min_marity__n4__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(check_min_marity__n5__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(check_min_marity__n6__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(check_min_marity__n7__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(check_min_marity__n8__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(check_min_marity__n9__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(check_min_marity__n10__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(check_min_marity__nR__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(check_min_marity_m_malt__n0__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(check_min_marity_m_malt__n1__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(check_min_marity_m_malt__n2__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(check_min_marity_m_malt__n3__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(check_min_marity_m_malt__n4__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(check_min_marity_m_malt__n5__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(check_min_marity_m_malt__n6__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(check_min_marity_m_malt__n7__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(check_min_marity_m_malt__n8__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(check_min_marity_m_malt__n9__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(check_min_marity_m_malt__n10__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(check_min_marity_m_malt__nR__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(copy_mfrom_mliteral__nR),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(copy_mfrom_mregister___rrR),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(copy_mto_mregister___rrR),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(drop),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(drop_mnip),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(dup),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(exitvm),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(fail__retR),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(gc_mif_mneeded__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(heap_mallocate__n4),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(heap_mallocate__n8),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(heap_mallocate__n12),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(heap_mallocate__n16),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(heap_mallocate__n24),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(heap_mallocate__n32),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(heap_mallocate__n36),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(heap_mallocate__n48),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(heap_mallocate__n52),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(heap_mallocate__n64),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(heap_mallocate__nR),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(literal_mto_mregister__nR___rrR),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(nip),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(nip_mdrop),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(nip_mfive),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(nip_mfive_mdrop),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(nip_mfour),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(nip_mfour_mdrop),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(nip_mpush_mliteral__nR),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(nip_mpush_mregister___rrR),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(nip_msix),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(nip_msix_mdrop),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(nip_mthree),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(nip_mthree_mdrop),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(nip_mtwo),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(nip_mtwo_mdrop),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(nop),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(one_mminus_mregister___rrR___rrR__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(one_mplus_mregister___rrR___rrR__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(pop_mto_mglobal__nR__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(pop_mto_mglobal_mdefined__nR__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(pop_mto_mregister___rrR),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive__nR__n0__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive__nR__n1__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive__nR__n2__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive__nR__n3__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive__nR__n4__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive__nR__nR__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive_mboolean_mcanonicalize),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive_mbox),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive_mbox_mget__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive_mbox_msetb_mspecial__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive_mcar__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive_mcdr__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive_mcharacterp),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive_mcons_mspecial),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive_mconsp),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive_meqp),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive_mfixnum_meqp__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive_mfixnum_mnot_meqp__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive_mfixnump),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive_mgreaterp__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive_mlessp__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive_mnegate__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive_mnegativep__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive_mnon_mconsp),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive_mnon_mnegativep__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive_mnon_mnullp),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive_mnon_mpositivep__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive_mnon_msymbolp),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive_mnon_mzerop__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive_mnot),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive_mnot_meqp),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive_mnot_mgreaterp__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive_mnot_mlessp__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive_mnothingp),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive_mnullp),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive_mone_mminus__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive_mone_mplus__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive_mpositivep__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive_mprimordial_mdivided__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive_mprimordial_mdivided_munsafe__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive_mprimordial_mminus__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive_mprimordial_mplus__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive_mprimordial_mtimes__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive_mquotient__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive_mquotient_munsafe__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive_mremainder__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive_mremainder_munsafe__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive_mset_mcarb_mspecial__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive_mset_mcdrb_mspecial__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive_msymbolp),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive_mtwo_mdivided__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive_mtwo_mquotient__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive_mtwo_mremainder__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive_mtwo_mtimes__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive_muniquep),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive_mzerop__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(procedure_mprolog),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(push_mfalse),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(push_mglobal__nR__fR),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(push_mliteral__nR),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(push_mnil),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(push_mnothing),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(push_mone),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(push_mregister___rrR),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(push_munspecified),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(push_mzero),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(register_mto_mregister___rrR___rrR),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(restore_mregister___rrR),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(return),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(save_mregister___rrR),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(tail_mcall__n0__retR),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(tail_mcall__n1__retR),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(tail_mcall__n2__retR),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(tail_mcall__n3__retR),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(tail_mcall__n4__retR),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(tail_mcall__n5__retR),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(tail_mcall__n6__retR),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(tail_mcall__n7__retR),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(tail_mcall__n8__retR),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(tail_mcall__n9__retR),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(tail_mcall__n10__retR),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(tail_mcall__nR__retR),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(tail_mcall_mcompiled__n0__retR),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(tail_mcall_mcompiled__n1__retR),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(tail_mcall_mcompiled__n2__retR),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(tail_mcall_mcompiled__n3__retR),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(tail_mcall_mcompiled__n4__retR),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(tail_mcall_mcompiled__n5__retR),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(tail_mcall_mcompiled__n6__retR),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(tail_mcall_mcompiled__n7__retR),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(tail_mcall_mcompiled__n8__retR),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(tail_mcall_mcompiled__n9__retR),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(tail_mcall_mcompiled__n10__retR),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(tail_mcall_mcompiled__nR__retR),
            && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(unreachable),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eREPLACEMENT_mbranch__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eREPLACEMENT_mbranch_mif_mfalse__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eREPLACEMENT_mbranch_mif_mnon_mpositive__fR__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eREPLACEMENT_mbranch_mif_mnot_mless__fR__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eREPLACEMENT_mbranch_mif_mnot_mnull__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eREPLACEMENT_mbranch_mif_mnull__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eREPLACEMENT_mbranch_mif_mpositive__fR__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eREPLACEMENT_mbranch_mif_mregister_mnon_mpositive___rrR__fR__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eREPLACEMENT_mbranch_mif_mregister_mnon_mzero___rrR__fR__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eREPLACEMENT_mbranch_mif_mregister_mnot_mnull___rrR__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eREPLACEMENT_mbranch_mif_mregister_mnull___rrR__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eREPLACEMENT_mbranch_mif_mregister_mpositive___rrR__fR__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eREPLACEMENT_mbranch_mif_mtrue__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eREPLACEMENT_mcall__n0__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eREPLACEMENT_mcall__n1__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eREPLACEMENT_mcall__n2__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eREPLACEMENT_mcall__n3__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eREPLACEMENT_mcall__n4__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eREPLACEMENT_mcall__n5__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eREPLACEMENT_mcall__n6__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eREPLACEMENT_mcall__n7__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eREPLACEMENT_mcall__n8__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eREPLACEMENT_mcall__n9__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eREPLACEMENT_mcall__n10__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eREPLACEMENT_mcall__nR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eREPLACEMENT_mcall_mcompiled__n0__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eREPLACEMENT_mcall_mcompiled__n1__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eREPLACEMENT_mcall_mcompiled__n2__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eREPLACEMENT_mcall_mcompiled__n3__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eREPLACEMENT_mcall_mcompiled__n4__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eREPLACEMENT_mcall_mcompiled__n5__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eREPLACEMENT_mcall_mcompiled__n6__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eREPLACEMENT_mcall_mcompiled__n7__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eREPLACEMENT_mcall_mcompiled__n8__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eREPLACEMENT_mcall_mcompiled__n9__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eREPLACEMENT_mcall_mcompiled__n10__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eREPLACEMENT_mcall_mcompiled__nR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eREPLACEMENT_mcall_mfrom_mc__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eREPLACEMENT_mcdr_mregister___rrR___rrR__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eREPLACEMENT_mcheck_mclosure__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eREPLACEMENT_mcheck_mglobal_mdefined__nR__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eREPLACEMENT_mcheck_min_marity__n0__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eREPLACEMENT_mcheck_min_marity__n1__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eREPLACEMENT_mcheck_min_marity__n2__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eREPLACEMENT_mcheck_min_marity__n3__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eREPLACEMENT_mcheck_min_marity__n4__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eREPLACEMENT_mcheck_min_marity__n5__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eREPLACEMENT_mcheck_min_marity__n6__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eREPLACEMENT_mcheck_min_marity__n7__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eREPLACEMENT_mcheck_min_marity__n8__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eREPLACEMENT_mcheck_min_marity__n9__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eREPLACEMENT_mcheck_min_marity__n10__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eREPLACEMENT_mcheck_min_marity__nR__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eREPLACEMENT_mcheck_min_marity_m_malt__n0__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eREPLACEMENT_mcheck_min_marity_m_malt__n1__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eREPLACEMENT_mcheck_min_marity_m_malt__n2__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eREPLACEMENT_mcheck_min_marity_m_malt__n3__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eREPLACEMENT_mcheck_min_marity_m_malt__n4__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eREPLACEMENT_mcheck_min_marity_m_malt__n5__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eREPLACEMENT_mcheck_min_marity_m_malt__n6__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eREPLACEMENT_mcheck_min_marity_m_malt__n7__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eREPLACEMENT_mcheck_min_marity_m_malt__n8__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eREPLACEMENT_mcheck_min_marity_m_malt__n9__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eREPLACEMENT_mcheck_min_marity_m_malt__n10__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eREPLACEMENT_mcheck_min_marity_m_malt__nR__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eREPLACEMENT_mexitvm__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eREPLACEMENT_mgc_mif_mneeded__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eREPLACEMENT_mone_mminus_mregister___rrR___rrR__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eREPLACEMENT_mone_mplus_mregister___rrR___rrR__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eREPLACEMENT_mpop_mto_mglobal__nR__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eREPLACEMENT_mpop_mto_mglobal_mdefined__nR__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eREPLACEMENT_mprimitive__nR__n0__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eREPLACEMENT_mprimitive__nR__n1__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eREPLACEMENT_mprimitive__nR__n2__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eREPLACEMENT_mprimitive__nR__n3__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eREPLACEMENT_mprimitive__nR__n4__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eREPLACEMENT_mprimitive__nR__nR__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eREPLACEMENT_mprimitive_mbox_mget__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eREPLACEMENT_mprimitive_mbox_msetb_mspecial__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eREPLACEMENT_mprimitive_mcar__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eREPLACEMENT_mprimitive_mcdr__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eREPLACEMENT_mprimitive_mfixnum_meqp__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eREPLACEMENT_mprimitive_mfixnum_mnot_meqp__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eREPLACEMENT_mprimitive_mgreaterp__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eREPLACEMENT_mprimitive_mlessp__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eREPLACEMENT_mprimitive_mnegate__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eREPLACEMENT_mprimitive_mnegativep__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eREPLACEMENT_mprimitive_mnon_mnegativep__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eREPLACEMENT_mprimitive_mnon_mpositivep__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eREPLACEMENT_mprimitive_mnon_mzerop__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eREPLACEMENT_mprimitive_mnot_mgreaterp__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eREPLACEMENT_mprimitive_mnot_mlessp__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eREPLACEMENT_mprimitive_mone_mminus__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eREPLACEMENT_mprimitive_mone_mplus__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eREPLACEMENT_mprimitive_mpositivep__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eREPLACEMENT_mprimitive_mprimordial_mdivided__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eREPLACEMENT_mprimitive_mprimordial_mdivided_munsafe__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eREPLACEMENT_mprimitive_mprimordial_mminus__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eREPLACEMENT_mprimitive_mprimordial_mplus__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eREPLACEMENT_mprimitive_mprimordial_mtimes__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eREPLACEMENT_mprimitive_mquotient__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eREPLACEMENT_mprimitive_mquotient_munsafe__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eREPLACEMENT_mprimitive_mremainder__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eREPLACEMENT_mprimitive_mremainder_munsafe__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eREPLACEMENT_mprimitive_mset_mcarb_mspecial__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eREPLACEMENT_mprimitive_mset_mcdrb_mspecial__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eREPLACEMENT_mprimitive_mtwo_mdivided__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eREPLACEMENT_mprimitive_mtwo_mquotient__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eREPLACEMENT_mprimitive_mtwo_mremainder__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eREPLACEMENT_mprimitive_mtwo_mtimes__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eREPLACEMENT_mprimitive_mzerop__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eREPLACEMENT_mprocedure_mprolog__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eREPLACEMENT_mpush_mglobal__nR__fR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eREPLACEMENT_mreturn__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eREPLACEMENT_mtail_mcall__n0__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eREPLACEMENT_mtail_mcall__n1__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eREPLACEMENT_mtail_mcall__n2__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eREPLACEMENT_mtail_mcall__n3__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eREPLACEMENT_mtail_mcall__n4__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eREPLACEMENT_mtail_mcall__n5__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eREPLACEMENT_mtail_mcall__n6__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eREPLACEMENT_mtail_mcall__n7__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eREPLACEMENT_mtail_mcall__n8__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eREPLACEMENT_mtail_mcall__n9__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eREPLACEMENT_mtail_mcall__n10__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eREPLACEMENT_mtail_mcall__nR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eREPLACEMENT_mtail_mcall_mcompiled__n0__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eREPLACEMENT_mtail_mcall_mcompiled__n1__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eREPLACEMENT_mtail_mcall_mcompiled__n2__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eREPLACEMENT_mtail_mcall_mcompiled__n3__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eREPLACEMENT_mtail_mcall_mcompiled__n4__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eREPLACEMENT_mtail_mcall_mcompiled__n5__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eREPLACEMENT_mtail_mcall_mcompiled__n6__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eREPLACEMENT_mtail_mcall_mcompiled__n7__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eREPLACEMENT_mtail_mcall_mcompiled__n8__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eREPLACEMENT_mtail_mcall_mcompiled__n9__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eREPLACEMENT_mtail_mcall_mcompiled__n10__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eREPLACEMENT_mtail_mcall_mcompiled__nR__retR),
                0),
            JITTER_IF2_DEFECT_
               (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eREPLACEMENT_munreachable__retR),
                0)
          };
      /* A few non-GCC compilers such as TCC support GNU C's labels
         as values, but do not recognise their differences as
         *constant* expressions.  Compute the difference at
         initialisation then. */
      static long
      jitterlispvm_the_thread_sizes [JITTERLISPVM_SPECIALIZED_INSTRUCTION_NO];
      int i;
      for (i = 0; i < JITTERLISPVM_SPECIALIZED_INSTRUCTION_NO; i ++)
        jitterlispvm_the_thread_sizes [i]
          = jitterlispvm_the_thread_ends [i] - jitterlispvm_the_threads [i];
      jitterlispvm_thread_sizes
        = (const long *) jitterlispvm_the_thread_sizes;
      jitterlispvm_threads = jitterlispvm_the_threads;
      jitterlispvm_thread_ends = jitterlispvm_the_thread_ends;

#ifdef JITTER_HAVE_DEFECT_REPLACEMENT
      /* Define the correct distance between the fake target in C
         and in assembly, for this VM. */
      JITTER_DEFECT_CORRECT_DISPLACEMENT_NAME (jitterlispvm)
        = ((char *) && jitter_fake_target
           - (char *) jitterlispvm_fake_target_asm);
      //fprintf (stderr, "DEBUG: INITIALISE CORRECT DISPLACEMENT TO %li\n", (long) JITTER_DEFECT_CORRECT_DISPLACEMENT_NAME (jitterlispvm));
#endif // #ifdef JITTER_HAVE_DEFECT_REPLACEMENT

#endif // #ifndef JITTER_DISPATCH_SWITCH

      /* Back to regular C, without our reserved registers if any; I can share
         the end code with the non-initialization case. */
#ifdef JITTER_HAVE_PATCH_IN
      //JITTER_DUMP_PATCH_IN_DESCRIPTORS(jitterlispvm);
#endif // #ifdef JITTER_HAVE_PATCH_IN
      goto jitter_possibly_restore_registers_and_return_label;
    }


  /* Before setting up runtime structures and jumping to the first
     instruction check that the last exit status was correct, and
     update it for the present run. */
  switch (_JITTER_STATE_BACKING_FIELD (exit_status))
    {
    case jitterlispvm_exit_status_never_executed:
    case jitterlispvm_exit_status_exited:
    case jitterlispvm_exit_status_debug:
      /* This is normal and expected. */
      _JITTER_STATE_BACKING_FIELD (exit_status)
        = jitterlispvm_exit_status_being_executed;
      break;

    case jitterlispvm_exit_status_being_executed:
      jitter_fatal ("the exit status before execution is "
                    "jitterlispvm_exit_status_being_executed: "
                    "you may have exited the last evaluation "
                    "through longjmp, or reused the same VM "
                    "state for a new execution with a previous "
                    "execution still in progress.");

    default:
      jitter_fatal ("invalid exit state %i",
                    (int) _JITTER_STATE_BACKING_FIELD (exit_status));
    }

  /* Here is the actual *executor* initialization, to be run before
     actually running the code. */

/* Selectively suppress suprious -Wmaybe-uninitialized .
   The indirect jump hack I use in profiling mode in order to
   have a large gap inside a function introduced by assembler without
   being restricted by jump offset limits (intentionally) tricks GCC
   into believing that the indirect jump may reach any instruction label;
   GCC would then warn that some locals might be used uninitialized,
   by skipping over their initialization.  This however is not possible,
   and I want to selectively silence the warning for the variables in
   question. */
//#pragma GCC diagnostic push
//#pragma GCC diagnostic ignored "-Wmaybe-uninitialized"

  /* Wrap functions and globals used within VM instructions, if needed.
     This is a trick to keep instructions readable while avoiding PC-relative
     addressing, which would mess up replicated code. */
#ifdef JITTER_REPLICATE

  /* Protect the C globals used in VM instructions so that they are always
     referred thru a pointer (from a register or the stack) set in the
     non-replicated part.  This is necessary on architectures where I can't
     force global references to pass thru a GOT.
     [FIXME: possibly don't do this on architectures that don't need it.] */

  typeof (jitterlispvm_states) * volatile _my_volatile_pointer_to_jitterlispvm_states = & jitterlispvm_states;
  typeof (jitterlispvm_states) * const restrict _my_pointer_to_jitterlispvm_states __attribute__ ((unused))
     = _my_volatile_pointer_to_jitterlispvm_states;
# undef jitterlispvm_states
# define jitterlispvm_states (* _my_pointer_to_jitterlispvm_states)

  typeof (stack_printf_format_string) * volatile _my_volatile_pointer_to_stack_printf_format_string = & stack_printf_format_string;
  typeof (stack_printf_format_string) * const restrict _my_pointer_to_stack_printf_format_string __attribute__ ((unused))
     = _my_volatile_pointer_to_stack_printf_format_string;
# undef stack_printf_format_string
# define stack_printf_format_string (* _my_pointer_to_stack_printf_format_string)

  /* Similarly, wrap the C functions used in VM instructions, so that they are
     always called thru a function pointer.  This is necessary on architectures
     where call instructions represent the callee as a PC-relative address.
     Unfortunately C has a special quirky syntax for function pointers, so I
     can't just use the code above.  [FIXME: don't do this on architectures
     that don't need it.] */
  typeof (jitterlispvm_error_invalid_primitive_argument_type_friendly) * volatile _jitter_my_volatile_pointer_to_jitterlispvm_error_invalid_primitive_argument_type_friendly = & jitterlispvm_error_invalid_primitive_argument_type_friendly;
  typeof (jitterlispvm_error_invalid_primitive_argument_type_friendly) * const _jitter_my_jitterlispvm_error_invalid_primitive_argument_type_friendly __attribute__ ((unused))
     = * _jitter_my_volatile_pointer_to_jitterlispvm_error_invalid_primitive_argument_type_friendly;
# undef jitterlispvm_error_invalid_primitive_argument_type_friendly
# define jitterlispvm_error_invalid_primitive_argument_type_friendly(...)  \
  JITTER_CALL_C (_jitter_my_jitterlispvm_error_invalid_primitive_argument_type_friendly, __VA_ARGS__)
  typeof (jitterlispvm_error_invalid_primitive_argument_type_unfriendly) * volatile _jitter_my_volatile_pointer_to_jitterlispvm_error_invalid_primitive_argument_type_unfriendly = & jitterlispvm_error_invalid_primitive_argument_type_unfriendly;
  typeof (jitterlispvm_error_invalid_primitive_argument_type_unfriendly) * const _jitter_my_jitterlispvm_error_invalid_primitive_argument_type_unfriendly __attribute__ ((unused))
     = * _jitter_my_volatile_pointer_to_jitterlispvm_error_invalid_primitive_argument_type_unfriendly;
# undef jitterlispvm_error_invalid_primitive_argument_type_unfriendly
# define jitterlispvm_error_invalid_primitive_argument_type_unfriendly(...)  \
  JITTER_CALL_C (_jitter_my_jitterlispvm_error_invalid_primitive_argument_type_unfriendly, __VA_ARGS__)
  typeof (jitterlisp_fail_from_vm) * volatile _jitter_my_volatile_pointer_to_jitterlisp_fail_from_vm = & jitterlisp_fail_from_vm;
  typeof (jitterlisp_fail_from_vm) * const _jitter_my_jitterlisp_fail_from_vm __attribute__ ((unused))
     = * _jitter_my_volatile_pointer_to_jitterlisp_fail_from_vm;
# undef jitterlisp_fail_from_vm
# define jitterlisp_fail_from_vm(...)  \
  JITTER_CALL_C (_jitter_my_jitterlisp_fail_from_vm, __VA_ARGS__)
  typeof (jitterlisp_allocate) * volatile _jitter_my_volatile_pointer_to_jitterlisp_allocate = & jitterlisp_allocate;
  typeof (jitterlisp_allocate) * const _jitter_my_jitterlisp_allocate __attribute__ ((unused))
     = * _jitter_my_volatile_pointer_to_jitterlisp_allocate;
# undef jitterlisp_allocate
# define jitterlisp_allocate(...)  \
  JITTER_CALL_C (_jitter_my_jitterlisp_allocate, __VA_ARGS__)
  typeof (jitterlisp_call_interpreted) * volatile _jitter_my_volatile_pointer_to_jitterlisp_call_interpreted = & jitterlisp_call_interpreted;
  typeof (jitterlisp_call_interpreted) * const _jitter_my_jitterlisp_call_interpreted __attribute__ ((unused))
     = * _jitter_my_volatile_pointer_to_jitterlisp_call_interpreted;
# undef jitterlisp_call_interpreted
# define jitterlisp_call_interpreted(...)  \
  JITTER_CALL_C (_jitter_my_jitterlisp_call_interpreted, __VA_ARGS__)
  typeof (jitterlisp_print) * volatile _jitter_my_volatile_pointer_to_jitterlisp_print = & jitterlisp_print;
  typeof (jitterlisp_print) * const _jitter_my_jitterlisp_print __attribute__ ((unused))
     = * _jitter_my_volatile_pointer_to_jitterlisp_print;
# undef jitterlisp_print
# define jitterlisp_print(...)  \
  JITTER_CALL_C (_jitter_my_jitterlisp_print, __VA_ARGS__)
  typeof (debug_pointer) * volatile _jitter_my_volatile_pointer_to_debug_pointer = & debug_pointer;
  typeof (debug_pointer) * const _jitter_my_debug_pointer __attribute__ ((unused))
     = * _jitter_my_volatile_pointer_to_debug_pointer;
# undef debug_pointer
# define debug_pointer(...)  \
  JITTER_CALL_C (_jitter_my_debug_pointer, __VA_ARGS__)
/* See the comment above about spurious -Wmaybe-uninitialized warnings. */
//#pragma GCC diagnostic pop
#endif // #ifdef JITTER_REPLICATE


  /* Make an automatic struct holding a copy of the state whose pointer was given.
     The idea is that the copy should be in registers, as far as possible. */
  struct jitterlispvm_state_runtime jitter_state_runtime
    = jitter_original_state->_jitterlispvm_1TbNcL3hel_state_runtime;

  /* Initialize a pointer to The Array base.  This pointer will be in a
     global register variable with no-threading dispatch, and with
     other dispatches in an automatic variable, still hopefully kept
     in a register. */
/* About the pragma, look for "-Wmaybe-uninitialized" in the comments above. FIXME: this is to avoid a GCC warning with profiling.  Check with profiling on. */
//#pragma GCC diagnostic push
//#pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
#ifdef JITTER_DISPATCH_NO_THREADING
# define jitter_array_base jitterlispvm_array_base_register_variable
#else
  char * restrict jitter_array_base __attribute__ ((unused));
#endif // #ifdef JITTER_DISPATCH_NO_THREADING
//#pragma GCC diagnostic pop
  jitter_array_base
    = (((char *) jitter_original_state->jitterlispvm_state_backing.jitter_array)
       + JITTER_ARRAY_BIAS);

  /* Declare the instruction pointer from the thread array, unless the dispatch
     is no-threading, in which case no thread array even exists. */
  jitterlispvm_program_point jitter_ip = NULL; /* Invalidate to catch errors. */
#ifdef JITTER_REPLICATE
  /* Save an instruction address within this function, to jump to at VM exit
     time; that way we can be sure that at exit time we are back to
     non-replicated code, and stuff like PC-relative addressing work again
     without special tricks.  This variable may safely (and actually should,
     for performance) be kept on the stack.  We need it to be volatile to
     prevent the compiler from being too clever and jump to it using a
     PC-relative displacement from replicated code.   It must not be static,
     since non-automatic variables are problematic to access from replicated
     code, which might use PC-relative addressing. */
  volatile typeof (&& jitter_exit_vm_label) restrict
  jitter_saved_exit_non_replicated_code_pointer = &&jitter_exit_vm_label;
  JITTER_MARK_MEMORY_AS_SET_BY_ASSEMBLY(jitter_saved_exit_non_replicated_code_pointer);
#endif // #ifdef JITTER_REPLICATE


#ifdef JITTER_REPLICATE
  /* FIXME: comment. */
  volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(fail__retR)
    = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(fail__retR);
  asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(fail__retR)) "\n"
                : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(fail__retR)));
  volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mbranch__fR__retR)
    = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_eREPLACEMENT_mbranch__fR__retR);
  asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mbranch__fR__retR)) "\n"
                : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mbranch__fR__retR)));
  volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mbranch_mif_mfalse__fR__retR)
    = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_eREPLACEMENT_mbranch_mif_mfalse__fR__retR);
  asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mbranch_mif_mfalse__fR__retR)) "\n"
                : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mbranch_mif_mfalse__fR__retR)));
  volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mbranch_mif_mnon_mpositive__fR__fR__retR)
    = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_eREPLACEMENT_mbranch_mif_mnon_mpositive__fR__fR__retR);
  asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mbranch_mif_mnon_mpositive__fR__fR__retR)) "\n"
                : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mbranch_mif_mnon_mpositive__fR__fR__retR)));
  volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mbranch_mif_mnot_mless__fR__fR__retR)
    = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_eREPLACEMENT_mbranch_mif_mnot_mless__fR__fR__retR);
  asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mbranch_mif_mnot_mless__fR__fR__retR)) "\n"
                : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mbranch_mif_mnot_mless__fR__fR__retR)));
  volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mbranch_mif_mnot_mnull__fR__retR)
    = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_eREPLACEMENT_mbranch_mif_mnot_mnull__fR__retR);
  asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mbranch_mif_mnot_mnull__fR__retR)) "\n"
                : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mbranch_mif_mnot_mnull__fR__retR)));
  volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mbranch_mif_mnull__fR__retR)
    = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_eREPLACEMENT_mbranch_mif_mnull__fR__retR);
  asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mbranch_mif_mnull__fR__retR)) "\n"
                : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mbranch_mif_mnull__fR__retR)));
  volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mbranch_mif_mpositive__fR__fR__retR)
    = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_eREPLACEMENT_mbranch_mif_mpositive__fR__fR__retR);
  asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mbranch_mif_mpositive__fR__fR__retR)) "\n"
                : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mbranch_mif_mpositive__fR__fR__retR)));
  volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mbranch_mif_mregister_mnon_mpositive___rrR__fR__fR__retR)
    = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_eREPLACEMENT_mbranch_mif_mregister_mnon_mpositive___rrR__fR__fR__retR);
  asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mbranch_mif_mregister_mnon_mpositive___rrR__fR__fR__retR)) "\n"
                : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mbranch_mif_mregister_mnon_mpositive___rrR__fR__fR__retR)));
  volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mbranch_mif_mregister_mnon_mzero___rrR__fR__fR__retR)
    = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_eREPLACEMENT_mbranch_mif_mregister_mnon_mzero___rrR__fR__fR__retR);
  asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mbranch_mif_mregister_mnon_mzero___rrR__fR__fR__retR)) "\n"
                : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mbranch_mif_mregister_mnon_mzero___rrR__fR__fR__retR)));
  volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mbranch_mif_mregister_mnot_mnull___rrR__fR__retR)
    = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_eREPLACEMENT_mbranch_mif_mregister_mnot_mnull___rrR__fR__retR);
  asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mbranch_mif_mregister_mnot_mnull___rrR__fR__retR)) "\n"
                : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mbranch_mif_mregister_mnot_mnull___rrR__fR__retR)));
  volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mbranch_mif_mregister_mnull___rrR__fR__retR)
    = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_eREPLACEMENT_mbranch_mif_mregister_mnull___rrR__fR__retR);
  asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mbranch_mif_mregister_mnull___rrR__fR__retR)) "\n"
                : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mbranch_mif_mregister_mnull___rrR__fR__retR)));
  volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mbranch_mif_mregister_mpositive___rrR__fR__fR__retR)
    = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_eREPLACEMENT_mbranch_mif_mregister_mpositive___rrR__fR__fR__retR);
  asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mbranch_mif_mregister_mpositive___rrR__fR__fR__retR)) "\n"
                : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mbranch_mif_mregister_mpositive___rrR__fR__fR__retR)));
  volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mbranch_mif_mtrue__fR__retR)
    = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_eREPLACEMENT_mbranch_mif_mtrue__fR__retR);
  asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mbranch_mif_mtrue__fR__retR)) "\n"
                : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mbranch_mif_mtrue__fR__retR)));
  volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mcall__n0__retR)
    = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_eREPLACEMENT_mcall__n0__retR);
  asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mcall__n0__retR)) "\n"
                : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mcall__n0__retR)));
  volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mcall__n1__retR)
    = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_eREPLACEMENT_mcall__n1__retR);
  asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mcall__n1__retR)) "\n"
                : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mcall__n1__retR)));
  volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mcall__n2__retR)
    = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_eREPLACEMENT_mcall__n2__retR);
  asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mcall__n2__retR)) "\n"
                : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mcall__n2__retR)));
  volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mcall__n3__retR)
    = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_eREPLACEMENT_mcall__n3__retR);
  asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mcall__n3__retR)) "\n"
                : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mcall__n3__retR)));
  volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mcall__n4__retR)
    = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_eREPLACEMENT_mcall__n4__retR);
  asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mcall__n4__retR)) "\n"
                : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mcall__n4__retR)));
  volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mcall__n5__retR)
    = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_eREPLACEMENT_mcall__n5__retR);
  asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mcall__n5__retR)) "\n"
                : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mcall__n5__retR)));
  volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mcall__n6__retR)
    = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_eREPLACEMENT_mcall__n6__retR);
  asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mcall__n6__retR)) "\n"
                : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mcall__n6__retR)));
  volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mcall__n7__retR)
    = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_eREPLACEMENT_mcall__n7__retR);
  asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mcall__n7__retR)) "\n"
                : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mcall__n7__retR)));
  volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mcall__n8__retR)
    = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_eREPLACEMENT_mcall__n8__retR);
  asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mcall__n8__retR)) "\n"
                : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mcall__n8__retR)));
  volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mcall__n9__retR)
    = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_eREPLACEMENT_mcall__n9__retR);
  asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mcall__n9__retR)) "\n"
                : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mcall__n9__retR)));
  volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mcall__n10__retR)
    = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_eREPLACEMENT_mcall__n10__retR);
  asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mcall__n10__retR)) "\n"
                : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mcall__n10__retR)));
  volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mcall__nR__retR)
    = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_eREPLACEMENT_mcall__nR__retR);
  asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mcall__nR__retR)) "\n"
                : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mcall__nR__retR)));
  volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mcall_mcompiled__n0__retR)
    = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_eREPLACEMENT_mcall_mcompiled__n0__retR);
  asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mcall_mcompiled__n0__retR)) "\n"
                : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mcall_mcompiled__n0__retR)));
  volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mcall_mcompiled__n1__retR)
    = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_eREPLACEMENT_mcall_mcompiled__n1__retR);
  asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mcall_mcompiled__n1__retR)) "\n"
                : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mcall_mcompiled__n1__retR)));
  volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mcall_mcompiled__n2__retR)
    = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_eREPLACEMENT_mcall_mcompiled__n2__retR);
  asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mcall_mcompiled__n2__retR)) "\n"
                : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mcall_mcompiled__n2__retR)));
  volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mcall_mcompiled__n3__retR)
    = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_eREPLACEMENT_mcall_mcompiled__n3__retR);
  asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mcall_mcompiled__n3__retR)) "\n"
                : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mcall_mcompiled__n3__retR)));
  volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mcall_mcompiled__n4__retR)
    = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_eREPLACEMENT_mcall_mcompiled__n4__retR);
  asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mcall_mcompiled__n4__retR)) "\n"
                : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mcall_mcompiled__n4__retR)));
  volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mcall_mcompiled__n5__retR)
    = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_eREPLACEMENT_mcall_mcompiled__n5__retR);
  asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mcall_mcompiled__n5__retR)) "\n"
                : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mcall_mcompiled__n5__retR)));
  volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mcall_mcompiled__n6__retR)
    = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_eREPLACEMENT_mcall_mcompiled__n6__retR);
  asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mcall_mcompiled__n6__retR)) "\n"
                : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mcall_mcompiled__n6__retR)));
  volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mcall_mcompiled__n7__retR)
    = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_eREPLACEMENT_mcall_mcompiled__n7__retR);
  asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mcall_mcompiled__n7__retR)) "\n"
                : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mcall_mcompiled__n7__retR)));
  volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mcall_mcompiled__n8__retR)
    = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_eREPLACEMENT_mcall_mcompiled__n8__retR);
  asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mcall_mcompiled__n8__retR)) "\n"
                : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mcall_mcompiled__n8__retR)));
  volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mcall_mcompiled__n9__retR)
    = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_eREPLACEMENT_mcall_mcompiled__n9__retR);
  asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mcall_mcompiled__n9__retR)) "\n"
                : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mcall_mcompiled__n9__retR)));
  volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mcall_mcompiled__n10__retR)
    = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_eREPLACEMENT_mcall_mcompiled__n10__retR);
  asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mcall_mcompiled__n10__retR)) "\n"
                : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mcall_mcompiled__n10__retR)));
  volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mcall_mcompiled__nR__retR)
    = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_eREPLACEMENT_mcall_mcompiled__nR__retR);
  asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mcall_mcompiled__nR__retR)) "\n"
                : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mcall_mcompiled__nR__retR)));
  volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mcall_mfrom_mc__retR)
    = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_eREPLACEMENT_mcall_mfrom_mc__retR);
  asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mcall_mfrom_mc__retR)) "\n"
                : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mcall_mfrom_mc__retR)));
  volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mcdr_mregister___rrR___rrR__fR__retR)
    = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_eREPLACEMENT_mcdr_mregister___rrR___rrR__fR__retR);
  asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mcdr_mregister___rrR___rrR__fR__retR)) "\n"
                : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mcdr_mregister___rrR___rrR__fR__retR)));
  volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mcheck_mclosure__fR__retR)
    = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_eREPLACEMENT_mcheck_mclosure__fR__retR);
  asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mcheck_mclosure__fR__retR)) "\n"
                : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mcheck_mclosure__fR__retR)));
  volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mcheck_mglobal_mdefined__nR__fR__retR)
    = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_eREPLACEMENT_mcheck_mglobal_mdefined__nR__fR__retR);
  asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mcheck_mglobal_mdefined__nR__fR__retR)) "\n"
                : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mcheck_mglobal_mdefined__nR__fR__retR)));
  volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mcheck_min_marity__n0__fR__retR)
    = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_eREPLACEMENT_mcheck_min_marity__n0__fR__retR);
  asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mcheck_min_marity__n0__fR__retR)) "\n"
                : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mcheck_min_marity__n0__fR__retR)));
  volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mcheck_min_marity__n1__fR__retR)
    = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_eREPLACEMENT_mcheck_min_marity__n1__fR__retR);
  asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mcheck_min_marity__n1__fR__retR)) "\n"
                : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mcheck_min_marity__n1__fR__retR)));
  volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mcheck_min_marity__n2__fR__retR)
    = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_eREPLACEMENT_mcheck_min_marity__n2__fR__retR);
  asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mcheck_min_marity__n2__fR__retR)) "\n"
                : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mcheck_min_marity__n2__fR__retR)));
  volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mcheck_min_marity__n3__fR__retR)
    = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_eREPLACEMENT_mcheck_min_marity__n3__fR__retR);
  asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mcheck_min_marity__n3__fR__retR)) "\n"
                : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mcheck_min_marity__n3__fR__retR)));
  volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mcheck_min_marity__n4__fR__retR)
    = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_eREPLACEMENT_mcheck_min_marity__n4__fR__retR);
  asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mcheck_min_marity__n4__fR__retR)) "\n"
                : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mcheck_min_marity__n4__fR__retR)));
  volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mcheck_min_marity__n5__fR__retR)
    = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_eREPLACEMENT_mcheck_min_marity__n5__fR__retR);
  asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mcheck_min_marity__n5__fR__retR)) "\n"
                : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mcheck_min_marity__n5__fR__retR)));
  volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mcheck_min_marity__n6__fR__retR)
    = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_eREPLACEMENT_mcheck_min_marity__n6__fR__retR);
  asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mcheck_min_marity__n6__fR__retR)) "\n"
                : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mcheck_min_marity__n6__fR__retR)));
  volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mcheck_min_marity__n7__fR__retR)
    = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_eREPLACEMENT_mcheck_min_marity__n7__fR__retR);
  asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mcheck_min_marity__n7__fR__retR)) "\n"
                : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mcheck_min_marity__n7__fR__retR)));
  volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mcheck_min_marity__n8__fR__retR)
    = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_eREPLACEMENT_mcheck_min_marity__n8__fR__retR);
  asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mcheck_min_marity__n8__fR__retR)) "\n"
                : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mcheck_min_marity__n8__fR__retR)));
  volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mcheck_min_marity__n9__fR__retR)
    = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_eREPLACEMENT_mcheck_min_marity__n9__fR__retR);
  asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mcheck_min_marity__n9__fR__retR)) "\n"
                : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mcheck_min_marity__n9__fR__retR)));
  volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mcheck_min_marity__n10__fR__retR)
    = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_eREPLACEMENT_mcheck_min_marity__n10__fR__retR);
  asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mcheck_min_marity__n10__fR__retR)) "\n"
                : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mcheck_min_marity__n10__fR__retR)));
  volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mcheck_min_marity__nR__fR__retR)
    = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_eREPLACEMENT_mcheck_min_marity__nR__fR__retR);
  asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mcheck_min_marity__nR__fR__retR)) "\n"
                : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mcheck_min_marity__nR__fR__retR)));
  volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mcheck_min_marity_m_malt__n0__fR__retR)
    = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_eREPLACEMENT_mcheck_min_marity_m_malt__n0__fR__retR);
  asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mcheck_min_marity_m_malt__n0__fR__retR)) "\n"
                : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mcheck_min_marity_m_malt__n0__fR__retR)));
  volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mcheck_min_marity_m_malt__n1__fR__retR)
    = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_eREPLACEMENT_mcheck_min_marity_m_malt__n1__fR__retR);
  asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mcheck_min_marity_m_malt__n1__fR__retR)) "\n"
                : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mcheck_min_marity_m_malt__n1__fR__retR)));
  volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mcheck_min_marity_m_malt__n2__fR__retR)
    = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_eREPLACEMENT_mcheck_min_marity_m_malt__n2__fR__retR);
  asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mcheck_min_marity_m_malt__n2__fR__retR)) "\n"
                : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mcheck_min_marity_m_malt__n2__fR__retR)));
  volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mcheck_min_marity_m_malt__n3__fR__retR)
    = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_eREPLACEMENT_mcheck_min_marity_m_malt__n3__fR__retR);
  asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mcheck_min_marity_m_malt__n3__fR__retR)) "\n"
                : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mcheck_min_marity_m_malt__n3__fR__retR)));
  volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mcheck_min_marity_m_malt__n4__fR__retR)
    = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_eREPLACEMENT_mcheck_min_marity_m_malt__n4__fR__retR);
  asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mcheck_min_marity_m_malt__n4__fR__retR)) "\n"
                : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mcheck_min_marity_m_malt__n4__fR__retR)));
  volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mcheck_min_marity_m_malt__n5__fR__retR)
    = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_eREPLACEMENT_mcheck_min_marity_m_malt__n5__fR__retR);
  asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mcheck_min_marity_m_malt__n5__fR__retR)) "\n"
                : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mcheck_min_marity_m_malt__n5__fR__retR)));
  volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mcheck_min_marity_m_malt__n6__fR__retR)
    = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_eREPLACEMENT_mcheck_min_marity_m_malt__n6__fR__retR);
  asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mcheck_min_marity_m_malt__n6__fR__retR)) "\n"
                : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mcheck_min_marity_m_malt__n6__fR__retR)));
  volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mcheck_min_marity_m_malt__n7__fR__retR)
    = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_eREPLACEMENT_mcheck_min_marity_m_malt__n7__fR__retR);
  asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mcheck_min_marity_m_malt__n7__fR__retR)) "\n"
                : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mcheck_min_marity_m_malt__n7__fR__retR)));
  volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mcheck_min_marity_m_malt__n8__fR__retR)
    = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_eREPLACEMENT_mcheck_min_marity_m_malt__n8__fR__retR);
  asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mcheck_min_marity_m_malt__n8__fR__retR)) "\n"
                : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mcheck_min_marity_m_malt__n8__fR__retR)));
  volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mcheck_min_marity_m_malt__n9__fR__retR)
    = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_eREPLACEMENT_mcheck_min_marity_m_malt__n9__fR__retR);
  asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mcheck_min_marity_m_malt__n9__fR__retR)) "\n"
                : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mcheck_min_marity_m_malt__n9__fR__retR)));
  volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mcheck_min_marity_m_malt__n10__fR__retR)
    = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_eREPLACEMENT_mcheck_min_marity_m_malt__n10__fR__retR);
  asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mcheck_min_marity_m_malt__n10__fR__retR)) "\n"
                : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mcheck_min_marity_m_malt__n10__fR__retR)));
  volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mcheck_min_marity_m_malt__nR__fR__retR)
    = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_eREPLACEMENT_mcheck_min_marity_m_malt__nR__fR__retR);
  asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mcheck_min_marity_m_malt__nR__fR__retR)) "\n"
                : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mcheck_min_marity_m_malt__nR__fR__retR)));
  volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mexitvm__retR)
    = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_eREPLACEMENT_mexitvm__retR);
  asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mexitvm__retR)) "\n"
                : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mexitvm__retR)));
  volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mgc_mif_mneeded__fR__retR)
    = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_eREPLACEMENT_mgc_mif_mneeded__fR__retR);
  asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mgc_mif_mneeded__fR__retR)) "\n"
                : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mgc_mif_mneeded__fR__retR)));
  volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mone_mminus_mregister___rrR___rrR__fR__retR)
    = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_eREPLACEMENT_mone_mminus_mregister___rrR___rrR__fR__retR);
  asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mone_mminus_mregister___rrR___rrR__fR__retR)) "\n"
                : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mone_mminus_mregister___rrR___rrR__fR__retR)));
  volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mone_mplus_mregister___rrR___rrR__fR__retR)
    = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_eREPLACEMENT_mone_mplus_mregister___rrR___rrR__fR__retR);
  asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mone_mplus_mregister___rrR___rrR__fR__retR)) "\n"
                : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mone_mplus_mregister___rrR___rrR__fR__retR)));
  volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mpop_mto_mglobal__nR__fR__retR)
    = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_eREPLACEMENT_mpop_mto_mglobal__nR__fR__retR);
  asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mpop_mto_mglobal__nR__fR__retR)) "\n"
                : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mpop_mto_mglobal__nR__fR__retR)));
  volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mpop_mto_mglobal_mdefined__nR__fR__retR)
    = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_eREPLACEMENT_mpop_mto_mglobal_mdefined__nR__fR__retR);
  asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mpop_mto_mglobal_mdefined__nR__fR__retR)) "\n"
                : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mpop_mto_mglobal_mdefined__nR__fR__retR)));
  volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mprimitive__nR__n0__fR__retR)
    = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_eREPLACEMENT_mprimitive__nR__n0__fR__retR);
  asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mprimitive__nR__n0__fR__retR)) "\n"
                : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mprimitive__nR__n0__fR__retR)));
  volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mprimitive__nR__n1__fR__retR)
    = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_eREPLACEMENT_mprimitive__nR__n1__fR__retR);
  asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mprimitive__nR__n1__fR__retR)) "\n"
                : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mprimitive__nR__n1__fR__retR)));
  volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mprimitive__nR__n2__fR__retR)
    = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_eREPLACEMENT_mprimitive__nR__n2__fR__retR);
  asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mprimitive__nR__n2__fR__retR)) "\n"
                : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mprimitive__nR__n2__fR__retR)));
  volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mprimitive__nR__n3__fR__retR)
    = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_eREPLACEMENT_mprimitive__nR__n3__fR__retR);
  asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mprimitive__nR__n3__fR__retR)) "\n"
                : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mprimitive__nR__n3__fR__retR)));
  volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mprimitive__nR__n4__fR__retR)
    = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_eREPLACEMENT_mprimitive__nR__n4__fR__retR);
  asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mprimitive__nR__n4__fR__retR)) "\n"
                : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mprimitive__nR__n4__fR__retR)));
  volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mprimitive__nR__nR__fR__retR)
    = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_eREPLACEMENT_mprimitive__nR__nR__fR__retR);
  asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mprimitive__nR__nR__fR__retR)) "\n"
                : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mprimitive__nR__nR__fR__retR)));
  volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mprimitive_mbox_mget__fR__retR)
    = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_eREPLACEMENT_mprimitive_mbox_mget__fR__retR);
  asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mprimitive_mbox_mget__fR__retR)) "\n"
                : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mprimitive_mbox_mget__fR__retR)));
  volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mprimitive_mbox_msetb_mspecial__fR__retR)
    = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_eREPLACEMENT_mprimitive_mbox_msetb_mspecial__fR__retR);
  asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mprimitive_mbox_msetb_mspecial__fR__retR)) "\n"
                : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mprimitive_mbox_msetb_mspecial__fR__retR)));
  volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mprimitive_mcar__fR__retR)
    = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_eREPLACEMENT_mprimitive_mcar__fR__retR);
  asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mprimitive_mcar__fR__retR)) "\n"
                : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mprimitive_mcar__fR__retR)));
  volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mprimitive_mcdr__fR__retR)
    = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_eREPLACEMENT_mprimitive_mcdr__fR__retR);
  asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mprimitive_mcdr__fR__retR)) "\n"
                : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mprimitive_mcdr__fR__retR)));
  volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mprimitive_mfixnum_meqp__fR__retR)
    = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_eREPLACEMENT_mprimitive_mfixnum_meqp__fR__retR);
  asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mprimitive_mfixnum_meqp__fR__retR)) "\n"
                : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mprimitive_mfixnum_meqp__fR__retR)));
  volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mprimitive_mfixnum_mnot_meqp__fR__retR)
    = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_eREPLACEMENT_mprimitive_mfixnum_mnot_meqp__fR__retR);
  asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mprimitive_mfixnum_mnot_meqp__fR__retR)) "\n"
                : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mprimitive_mfixnum_mnot_meqp__fR__retR)));
  volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mprimitive_mgreaterp__fR__retR)
    = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_eREPLACEMENT_mprimitive_mgreaterp__fR__retR);
  asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mprimitive_mgreaterp__fR__retR)) "\n"
                : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mprimitive_mgreaterp__fR__retR)));
  volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mprimitive_mlessp__fR__retR)
    = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_eREPLACEMENT_mprimitive_mlessp__fR__retR);
  asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mprimitive_mlessp__fR__retR)) "\n"
                : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mprimitive_mlessp__fR__retR)));
  volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mprimitive_mnegate__fR__retR)
    = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_eREPLACEMENT_mprimitive_mnegate__fR__retR);
  asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mprimitive_mnegate__fR__retR)) "\n"
                : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mprimitive_mnegate__fR__retR)));
  volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mprimitive_mnegativep__fR__retR)
    = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_eREPLACEMENT_mprimitive_mnegativep__fR__retR);
  asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mprimitive_mnegativep__fR__retR)) "\n"
                : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mprimitive_mnegativep__fR__retR)));
  volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mprimitive_mnon_mnegativep__fR__retR)
    = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_eREPLACEMENT_mprimitive_mnon_mnegativep__fR__retR);
  asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mprimitive_mnon_mnegativep__fR__retR)) "\n"
                : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mprimitive_mnon_mnegativep__fR__retR)));
  volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mprimitive_mnon_mpositivep__fR__retR)
    = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_eREPLACEMENT_mprimitive_mnon_mpositivep__fR__retR);
  asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mprimitive_mnon_mpositivep__fR__retR)) "\n"
                : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mprimitive_mnon_mpositivep__fR__retR)));
  volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mprimitive_mnon_mzerop__fR__retR)
    = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_eREPLACEMENT_mprimitive_mnon_mzerop__fR__retR);
  asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mprimitive_mnon_mzerop__fR__retR)) "\n"
                : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mprimitive_mnon_mzerop__fR__retR)));
  volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mprimitive_mnot_mgreaterp__fR__retR)
    = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_eREPLACEMENT_mprimitive_mnot_mgreaterp__fR__retR);
  asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mprimitive_mnot_mgreaterp__fR__retR)) "\n"
                : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mprimitive_mnot_mgreaterp__fR__retR)));
  volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mprimitive_mnot_mlessp__fR__retR)
    = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_eREPLACEMENT_mprimitive_mnot_mlessp__fR__retR);
  asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mprimitive_mnot_mlessp__fR__retR)) "\n"
                : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mprimitive_mnot_mlessp__fR__retR)));
  volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mprimitive_mone_mminus__fR__retR)
    = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_eREPLACEMENT_mprimitive_mone_mminus__fR__retR);
  asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mprimitive_mone_mminus__fR__retR)) "\n"
                : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mprimitive_mone_mminus__fR__retR)));
  volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mprimitive_mone_mplus__fR__retR)
    = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_eREPLACEMENT_mprimitive_mone_mplus__fR__retR);
  asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mprimitive_mone_mplus__fR__retR)) "\n"
                : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mprimitive_mone_mplus__fR__retR)));
  volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mprimitive_mpositivep__fR__retR)
    = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_eREPLACEMENT_mprimitive_mpositivep__fR__retR);
  asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mprimitive_mpositivep__fR__retR)) "\n"
                : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mprimitive_mpositivep__fR__retR)));
  volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mprimitive_mprimordial_mdivided__fR__retR)
    = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_eREPLACEMENT_mprimitive_mprimordial_mdivided__fR__retR);
  asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mprimitive_mprimordial_mdivided__fR__retR)) "\n"
                : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mprimitive_mprimordial_mdivided__fR__retR)));
  volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mprimitive_mprimordial_mdivided_munsafe__fR__retR)
    = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_eREPLACEMENT_mprimitive_mprimordial_mdivided_munsafe__fR__retR);
  asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mprimitive_mprimordial_mdivided_munsafe__fR__retR)) "\n"
                : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mprimitive_mprimordial_mdivided_munsafe__fR__retR)));
  volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mprimitive_mprimordial_mminus__fR__retR)
    = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_eREPLACEMENT_mprimitive_mprimordial_mminus__fR__retR);
  asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mprimitive_mprimordial_mminus__fR__retR)) "\n"
                : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mprimitive_mprimordial_mminus__fR__retR)));
  volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mprimitive_mprimordial_mplus__fR__retR)
    = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_eREPLACEMENT_mprimitive_mprimordial_mplus__fR__retR);
  asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mprimitive_mprimordial_mplus__fR__retR)) "\n"
                : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mprimitive_mprimordial_mplus__fR__retR)));
  volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mprimitive_mprimordial_mtimes__fR__retR)
    = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_eREPLACEMENT_mprimitive_mprimordial_mtimes__fR__retR);
  asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mprimitive_mprimordial_mtimes__fR__retR)) "\n"
                : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mprimitive_mprimordial_mtimes__fR__retR)));
  volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mprimitive_mquotient__fR__retR)
    = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_eREPLACEMENT_mprimitive_mquotient__fR__retR);
  asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mprimitive_mquotient__fR__retR)) "\n"
                : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mprimitive_mquotient__fR__retR)));
  volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mprimitive_mquotient_munsafe__fR__retR)
    = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_eREPLACEMENT_mprimitive_mquotient_munsafe__fR__retR);
  asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mprimitive_mquotient_munsafe__fR__retR)) "\n"
                : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mprimitive_mquotient_munsafe__fR__retR)));
  volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mprimitive_mremainder__fR__retR)
    = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_eREPLACEMENT_mprimitive_mremainder__fR__retR);
  asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mprimitive_mremainder__fR__retR)) "\n"
                : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mprimitive_mremainder__fR__retR)));
  volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mprimitive_mremainder_munsafe__fR__retR)
    = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_eREPLACEMENT_mprimitive_mremainder_munsafe__fR__retR);
  asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mprimitive_mremainder_munsafe__fR__retR)) "\n"
                : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mprimitive_mremainder_munsafe__fR__retR)));
  volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mprimitive_mset_mcarb_mspecial__fR__retR)
    = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_eREPLACEMENT_mprimitive_mset_mcarb_mspecial__fR__retR);
  asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mprimitive_mset_mcarb_mspecial__fR__retR)) "\n"
                : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mprimitive_mset_mcarb_mspecial__fR__retR)));
  volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mprimitive_mset_mcdrb_mspecial__fR__retR)
    = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_eREPLACEMENT_mprimitive_mset_mcdrb_mspecial__fR__retR);
  asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mprimitive_mset_mcdrb_mspecial__fR__retR)) "\n"
                : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mprimitive_mset_mcdrb_mspecial__fR__retR)));
  volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mprimitive_mtwo_mdivided__fR__retR)
    = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_eREPLACEMENT_mprimitive_mtwo_mdivided__fR__retR);
  asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mprimitive_mtwo_mdivided__fR__retR)) "\n"
                : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mprimitive_mtwo_mdivided__fR__retR)));
  volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mprimitive_mtwo_mquotient__fR__retR)
    = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_eREPLACEMENT_mprimitive_mtwo_mquotient__fR__retR);
  asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mprimitive_mtwo_mquotient__fR__retR)) "\n"
                : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mprimitive_mtwo_mquotient__fR__retR)));
  volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mprimitive_mtwo_mremainder__fR__retR)
    = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_eREPLACEMENT_mprimitive_mtwo_mremainder__fR__retR);
  asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mprimitive_mtwo_mremainder__fR__retR)) "\n"
                : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mprimitive_mtwo_mremainder__fR__retR)));
  volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mprimitive_mtwo_mtimes__fR__retR)
    = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_eREPLACEMENT_mprimitive_mtwo_mtimes__fR__retR);
  asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mprimitive_mtwo_mtimes__fR__retR)) "\n"
                : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mprimitive_mtwo_mtimes__fR__retR)));
  volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mprimitive_mzerop__fR__retR)
    = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_eREPLACEMENT_mprimitive_mzerop__fR__retR);
  asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mprimitive_mzerop__fR__retR)) "\n"
                : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mprimitive_mzerop__fR__retR)));
  volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mprocedure_mprolog__retR)
    = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_eREPLACEMENT_mprocedure_mprolog__retR);
  asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mprocedure_mprolog__retR)) "\n"
                : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mprocedure_mprolog__retR)));
  volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mpush_mglobal__nR__fR__retR)
    = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_eREPLACEMENT_mpush_mglobal__nR__fR__retR);
  asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mpush_mglobal__nR__fR__retR)) "\n"
                : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mpush_mglobal__nR__fR__retR)));
  volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mreturn__retR)
    = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_eREPLACEMENT_mreturn__retR);
  asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mreturn__retR)) "\n"
                : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mreturn__retR)));
  volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mtail_mcall__n0__retR)
    = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_eREPLACEMENT_mtail_mcall__n0__retR);
  asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mtail_mcall__n0__retR)) "\n"
                : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mtail_mcall__n0__retR)));
  volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mtail_mcall__n1__retR)
    = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_eREPLACEMENT_mtail_mcall__n1__retR);
  asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mtail_mcall__n1__retR)) "\n"
                : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mtail_mcall__n1__retR)));
  volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mtail_mcall__n2__retR)
    = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_eREPLACEMENT_mtail_mcall__n2__retR);
  asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mtail_mcall__n2__retR)) "\n"
                : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mtail_mcall__n2__retR)));
  volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mtail_mcall__n3__retR)
    = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_eREPLACEMENT_mtail_mcall__n3__retR);
  asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mtail_mcall__n3__retR)) "\n"
                : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mtail_mcall__n3__retR)));
  volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mtail_mcall__n4__retR)
    = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_eREPLACEMENT_mtail_mcall__n4__retR);
  asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mtail_mcall__n4__retR)) "\n"
                : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mtail_mcall__n4__retR)));
  volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mtail_mcall__n5__retR)
    = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_eREPLACEMENT_mtail_mcall__n5__retR);
  asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mtail_mcall__n5__retR)) "\n"
                : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mtail_mcall__n5__retR)));
  volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mtail_mcall__n6__retR)
    = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_eREPLACEMENT_mtail_mcall__n6__retR);
  asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mtail_mcall__n6__retR)) "\n"
                : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mtail_mcall__n6__retR)));
  volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mtail_mcall__n7__retR)
    = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_eREPLACEMENT_mtail_mcall__n7__retR);
  asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mtail_mcall__n7__retR)) "\n"
                : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mtail_mcall__n7__retR)));
  volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mtail_mcall__n8__retR)
    = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_eREPLACEMENT_mtail_mcall__n8__retR);
  asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mtail_mcall__n8__retR)) "\n"
                : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mtail_mcall__n8__retR)));
  volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mtail_mcall__n9__retR)
    = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_eREPLACEMENT_mtail_mcall__n9__retR);
  asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mtail_mcall__n9__retR)) "\n"
                : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mtail_mcall__n9__retR)));
  volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mtail_mcall__n10__retR)
    = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_eREPLACEMENT_mtail_mcall__n10__retR);
  asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mtail_mcall__n10__retR)) "\n"
                : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mtail_mcall__n10__retR)));
  volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mtail_mcall__nR__retR)
    = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_eREPLACEMENT_mtail_mcall__nR__retR);
  asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mtail_mcall__nR__retR)) "\n"
                : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mtail_mcall__nR__retR)));
  volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mtail_mcall_mcompiled__n0__retR)
    = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_eREPLACEMENT_mtail_mcall_mcompiled__n0__retR);
  asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mtail_mcall_mcompiled__n0__retR)) "\n"
                : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mtail_mcall_mcompiled__n0__retR)));
  volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mtail_mcall_mcompiled__n1__retR)
    = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_eREPLACEMENT_mtail_mcall_mcompiled__n1__retR);
  asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mtail_mcall_mcompiled__n1__retR)) "\n"
                : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mtail_mcall_mcompiled__n1__retR)));
  volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mtail_mcall_mcompiled__n2__retR)
    = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_eREPLACEMENT_mtail_mcall_mcompiled__n2__retR);
  asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mtail_mcall_mcompiled__n2__retR)) "\n"
                : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mtail_mcall_mcompiled__n2__retR)));
  volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mtail_mcall_mcompiled__n3__retR)
    = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_eREPLACEMENT_mtail_mcall_mcompiled__n3__retR);
  asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mtail_mcall_mcompiled__n3__retR)) "\n"
                : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mtail_mcall_mcompiled__n3__retR)));
  volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mtail_mcall_mcompiled__n4__retR)
    = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_eREPLACEMENT_mtail_mcall_mcompiled__n4__retR);
  asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mtail_mcall_mcompiled__n4__retR)) "\n"
                : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mtail_mcall_mcompiled__n4__retR)));
  volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mtail_mcall_mcompiled__n5__retR)
    = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_eREPLACEMENT_mtail_mcall_mcompiled__n5__retR);
  asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mtail_mcall_mcompiled__n5__retR)) "\n"
                : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mtail_mcall_mcompiled__n5__retR)));
  volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mtail_mcall_mcompiled__n6__retR)
    = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_eREPLACEMENT_mtail_mcall_mcompiled__n6__retR);
  asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mtail_mcall_mcompiled__n6__retR)) "\n"
                : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mtail_mcall_mcompiled__n6__retR)));
  volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mtail_mcall_mcompiled__n7__retR)
    = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_eREPLACEMENT_mtail_mcall_mcompiled__n7__retR);
  asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mtail_mcall_mcompiled__n7__retR)) "\n"
                : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mtail_mcall_mcompiled__n7__retR)));
  volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mtail_mcall_mcompiled__n8__retR)
    = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_eREPLACEMENT_mtail_mcall_mcompiled__n8__retR);
  asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mtail_mcall_mcompiled__n8__retR)) "\n"
                : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mtail_mcall_mcompiled__n8__retR)));
  volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mtail_mcall_mcompiled__n9__retR)
    = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_eREPLACEMENT_mtail_mcall_mcompiled__n9__retR);
  asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mtail_mcall_mcompiled__n9__retR)) "\n"
                : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mtail_mcall_mcompiled__n9__retR)));
  volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mtail_mcall_mcompiled__n10__retR)
    = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_eREPLACEMENT_mtail_mcall_mcompiled__n10__retR);
  asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mtail_mcall_mcompiled__n10__retR)) "\n"
                : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mtail_mcall_mcompiled__n10__retR)));
  volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mtail_mcall_mcompiled__nR__retR)
    = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_eREPLACEMENT_mtail_mcall_mcompiled__nR__retR);
  asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mtail_mcall_mcompiled__nR__retR)) "\n"
                : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_mtail_mcall_mcompiled__nR__retR)));
  volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_munreachable__retR)
    = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_eREPLACEMENT_munreachable__retR);
  asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_munreachable__retR)) "\n"
                : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_eREPLACEMENT_munreachable__retR)));
#endif // #ifdef JITTER_REPLICATE

  /* Initialization C code from the user */

    /* End of the initialization C code from the user */


# if defined(JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined(JITTER_DISPATCH_NO_THREADING)
  /* Execute architecture-specific execution-beginning code, if any.
     Make sure it is safe to expand the macro without do..while
     (false), since the expansion may contain declarations of
     variables to be used later. */
  {}; JITTER_EXECUTION_BEGINNING_; {};
  /* Declare a variable used in asm constraints on some architectures:
     see the comment in jitter-executor.h . */
  volatile long _jitter_useless_variable __attribute__ ((unused))
    = 0;
# endif

#if defined (JITTERLISPVM_PROFILE_SAMPLE)
    /* Start sample-profiling: this starts the periodic timer signal,
       whose handler will look at the current instruction field within
       the special-purpose struct in the Array. */
    jitterlispvm_profile_sample_start (JITTERLISPVM_OWN_STATE);
#endif // #if defined (JITTERLISPVM_PROFILE_SAMPLE)

  /* Jump to the first instruction.  If replication is enabled this point
     marks the boundary between the ordinary world of C compiled code and
     the more fragile replicated code, where PC-relative address does
     not work as intended (which prevents the use of global and static
     variables, string literals and possibly large literal constants), and
     GDB gets easily confused. */
  jitter_ip
    = jitter_original_state->jitterlispvm_state_backing.initial_program_point;

  /* This is the actual jump to the first instruction: it's not an
     inline asm constraint lie like below. */

# if   defined(JITTER_DISPATCH_SWITCH)
    goto jitter_dispatching_switch_label;
# elif (defined(JITTER_DISPATCH_DIRECT_THREADING)  \
        || defined(JITTER_DISPATCH_MINIMAL_THREADING))
    goto * (jitter_ip->label);
# elif defined(JITTER_DISPATCH_NO_THREADING)
    /* On no-threading we only use jitter_ip for the first instruction.
       Make it an alias for the base, which will be enough to satisfy
       inline assembly code which pretends to alter the instruction
       pointer in ways invisible to the compiler.
       At least in my tests this trick frees up one hardware register,
       which is not surprising. */
    goto * jitter_ip;
#   define jitter_ip jitterlispvm_array_base_register_variable
# else
#   error "unknown dispatch"
# endif // if ... dispatch
#ifdef JITTER_REPLICATE
  JITTER_PRETEND_TO_UPDATE_IP_;
  JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE();
  goto jitter_fake_target;
#endif // #ifdef JITTER_REPLICATE

#ifdef JITTER_DISPATCH_SWITCH
  /* This is the dispatching switch.  At the beginning of the first VM
     VM instruction and at the end of each other, control jumps here. */
 jitter_dispatching_switch_label:
  switch (jitter_ip->fixnum)
    {
#endif // #ifdef JITTER_DISPATCH_SWITCH

#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
JITTER_INSTRUCTION_PROLOG_(!INVALID, _eINVALID, cold)
#define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
#define JITTER_SPECIALIZED_INSTRUCTION_OPCODE  0
#define JITTER_SPECIALIZED_INSTRUCTION_NAME  !INVALID
#define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME  _eINVALID
{

jitter_fatal ("reached the !INVALID instruction");
}
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
JITTER_INSTRUCTION_EPILOG_(!INVALID, _eINVALID, 0)
#undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
#undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
JITTER_INSTRUCTION_PROLOG_(!BEGINBASICBLOCK, _eBEGINBASICBLOCK, hot)
#define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
#define JITTER_SPECIALIZED_INSTRUCTION_OPCODE  1
#define JITTER_SPECIALIZED_INSTRUCTION_NAME  !BEGINBASICBLOCK
#define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME  _eBEGINBASICBLOCK
{

#ifdef JITTER_DISPATCH_MINIMAL_THREADING
  JITTER_SET_IP (jitter_ip + 1);
#endif // #ifdef JITTER_DISPATCH_MINIMAL_THREADING

}
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
JITTER_INSTRUCTION_EPILOG_(!BEGINBASICBLOCK, _eBEGINBASICBLOCK, 0)
#undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
#undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
JITTER_INSTRUCTION_PROLOG_(!EXITVM, _eEXITVM, cold)
#define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
#define JITTER_SPECIALIZED_INSTRUCTION_OPCODE  2
#define JITTER_SPECIALIZED_INSTRUCTION_NAME  !EXITVM
#define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME  _eEXITVM
{

_JITTER_EXIT();
}
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
JITTER_INSTRUCTION_EPILOG_(!EXITVM, _eEXITVM, 0)
#undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
#undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

JITTER_INSTRUCTION_PROLOG_(!DATALOCATIONS, _eDATALOCATIONS, cold)
#define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
#define JITTER_SPECIALIZED_INSTRUCTION_OPCODE  3
#define JITTER_SPECIALIZED_INSTRUCTION_NAME  !DATALOCATIONS
#define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME  _eDATALOCATIONS
{
#ifndef JITTER_DISPATCH_SWITCH
#ifndef JITTER_DISPATCH_NO_THREADING
  JITTER_DATA_LOCATION_DATUM ("instruction pointer", jitter_ip);
#endif // #ifndef JITTER_DISPATCH_NO_THREADING
  JITTER_DATA_LOCATION_DATUM ("base", jitter_array_base);
#ifdef JITTER_DISPATCH_NO_THREADING
#ifdef JITTER_SCRATCH_REGISTER
  JITTER_DATA_LOCATION_DATUM ("scratch", jitter_residual_argument_scratch_register_variable);
#endif // #ifdef JITTER_SCRATCH_REGISTER

#endif // #ifdef JITTER_DISPATCH_NO_THREADING
#ifdef JITTER_DISPATCH_NO_THREADING
#if (0 < JITTER_RESIDUAL_REGISTER_NO)
  JITTER_DATA_LOCATION_DATUM ("residual 0", jitter_residual_argument_0_register_variable);
#endif // #if (0 < JITTER_RESIDUAL_REGISTER_NO)
#if (1 < JITTER_RESIDUAL_REGISTER_NO)
  JITTER_DATA_LOCATION_DATUM ("residual 1", jitter_residual_argument_1_register_variable);
#endif // #if (1 < JITTER_RESIDUAL_REGISTER_NO)
#if (2 < JITTER_RESIDUAL_REGISTER_NO)
  JITTER_DATA_LOCATION_DATUM ("residual 2", jitter_residual_argument_2_register_variable);
#endif // #if (2 < JITTER_RESIDUAL_REGISTER_NO)
#if (3 < JITTER_RESIDUAL_REGISTER_NO)
  JITTER_DATA_LOCATION_DATUM ("residual 3", jitter_residual_argument_3_register_variable);
#endif // #if (3 < JITTER_RESIDUAL_REGISTER_NO)
#endif // #ifdef JITTER_DISPATCH_NO_THREADING
  JITTER_DATA_LOCATION_DATUM ("link register", jitter_state_runtime._jitter_link);
  JITTER_DATA_LOCATION_DATUM ("mainstack top", 
     JITTER_STACK_TOS_TOP_NAME (whatever, jitter_state_runtime., mainstack));
  JITTER_DATA_LOCATION_DATUM ("mainstack undertop ptr", 
     JITTER_STACK_TOS_UNDER_TOP_POINTER_NAME (whatever, jitter_state_runtime., mainstack));
  JITTER_DATA_LOCATION_DATUM ("returnstack top ptr", 
     JITTER_STACK_NTOS_TOP_POINTER_NAME (whatever, jitter_state_runtime., returnstack));
#endif // #ifndef JITTER_DISPATCH_SWITCH
}
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
JITTER_INSTRUCTION_EPILOG_(!DATALOCATIONS, _eDATALOCATIONS, 0)
#undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
#undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
JITTER_INSTRUCTION_PROLOG_(!NOP, _eNOP, cold)
#define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
#define JITTER_SPECIALIZED_INSTRUCTION_OPCODE  4
#define JITTER_SPECIALIZED_INSTRUCTION_NAME  !NOP
#define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME  _eNOP
{

  /* Do nothing. */;
}
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
JITTER_INSTRUCTION_EPILOG_(!NOP, _eNOP, 0)
#undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
#undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
JITTER_INSTRUCTION_PROLOG_(!UNREACHABLE0, _eUNREACHABLE0, cold)
#define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
#define JITTER_SPECIALIZED_INSTRUCTION_OPCODE  5
#define JITTER_SPECIALIZED_INSTRUCTION_NAME  !UNREACHABLE0
#define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME  _eUNREACHABLE0
{

jitter_fatal ("reached the !UNREACHABLE0 instruction");
}
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
JITTER_INSTRUCTION_EPILOG_(!UNREACHABLE0, _eUNREACHABLE0, 0)
#undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
#undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
JITTER_INSTRUCTION_PROLOG_(!UNREACHABLE1, _eUNREACHABLE1, cold)
#define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
#define JITTER_SPECIALIZED_INSTRUCTION_OPCODE  6
#define JITTER_SPECIALIZED_INSTRUCTION_NAME  !UNREACHABLE1
#define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME  _eUNREACHABLE1
{

jitter_fatal ("reached the !UNREACHABLE1 instruction");
}
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
JITTER_INSTRUCTION_EPILOG_(!UNREACHABLE1, _eUNREACHABLE1, 0)
#undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
#undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
JITTER_INSTRUCTION_PROLOG_(!PRETENDTOJUMPANYWHERE, _ePRETENDTOJUMPANYWHERE, cold)
#define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
#define JITTER_SPECIALIZED_INSTRUCTION_OPCODE  7
#define JITTER_SPECIALIZED_INSTRUCTION_NAME  !PRETENDTOJUMPANYWHERE
#define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME  _ePRETENDTOJUMPANYWHERE
jitter_fake_target: __attribute__ ((unused));{

#if ! defined(JITTER_DISPATCH_SWITCH)
  JITTER_PRETEND_TO_UPDATE_IP_;
  goto * jitter_ip;
#endif

}
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
JITTER_INSTRUCTION_EPILOG_(!PRETENDTOJUMPANYWHERE, _ePRETENDTOJUMPANYWHERE, 0)
#undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
#undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

  /* Ordinary specialized instructions. */
  /* Ordinary specialised instruction at-depth-to-register/n1/%rR */
  JITTER_INSTRUCTION_PROLOG_(at-depth-to-register/n1/%rR, at_mdepth_mto_mregister__n1___rrR, cold)
  { /* This block begins with definitions for at-depth-to-register/n1/%rR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       8
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         at-depth-to-register/n1/%rR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "at-depth-to-register"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "at-depth-to-register/n1/%rR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME at_mdepth_mto_mregister__n1___rrR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is not branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is not branching: undefine branch
       macros so that they cannot be used by mistake. */
/* Locally poison JITTER_COMPUTED_GOTO . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_COMPUTED_GOTO")
# undef JITTER_COMPUTED_GOTO
# define JITTER_COMPUTED_GOTO JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_COMPUTED_GOTO, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_COMPUTED_GOTO
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_COMPUTED_GOTO . */

/* Locally poison JITTER_BRANCH . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_BRANCH")
# undef JITTER_BRANCH
# define JITTER_BRANCH JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_BRANCH, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_BRANCH
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_BRANCH . */

/* Locally poison JITTER_EXIT . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_EXIT")
# undef JITTER_EXIT
# define JITTER_EXIT JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_EXIT, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_EXIT
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_EXIT . */

  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1

    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 1L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a slow (therefore residual, passed as an offset)
        register. */
  /* Define a macro expanding to the slow register offset. */
#if defined(JITTER_DISPATCH_NO_THREADING)
# define JITTER_SLOW_REGISTER_OFFSET1 (JITTER_RESIDUAL_ARGUMENT_0.fixnum)
#elif defined (JITTER_DISPATCH_MINIMAL_THREADING)
# define JITTER_SLOW_REGISTER_OFFSET1 ((((union jitter_word*)jitter_ip)[0]).fixnum)
#else
# define JITTER_SLOW_REGISTER_OFFSET1 ((((union jitter_word*)jitter_ip)[1]).fixnum)
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
  /* Define a macro expanding to an l-value for the VM register content. */
#   define JITTER_ARG1  JITTER_SLOW_REGISTER_FROM_OFFSET(r, JITTER_SLOW_REGISTER_OFFSET1)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1


#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of at-depth-to-register/n1/%rR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "at-depth-to-register/n1/%rR"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for at-depth-to-register/n1/%rR . */
  {
/* User-specified code, user code block part: beginning. */

    // FIXME: replace with JITTER_AT_DEPTH_UNSAFE_MAINSTACK after I implement
    // unsafe at-depth operations.
    JITTER_ARG1 = JITTER_AT_DEPTH_MAINSTACK(JITTER_ARGN0);
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for at-depth-to-register/n1/%rR . */

  //fprintf (stderr, "..Executed instruction %s\n", "at-depth-to-register/n1/%rR");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the at-depth-to-register/n1/%rR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_EXIT")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_BRANCH")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_COMPUTED_GOTO")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(at-depth-to-register/n1/%rR, at_mdepth_mto_mregister__n1___rrR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for at-depth-to-register/n1/%rR, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction at-depth-to-register/n2/%rR */
  JITTER_INSTRUCTION_PROLOG_(at-depth-to-register/n2/%rR, at_mdepth_mto_mregister__n2___rrR, cold)
  { /* This block begins with definitions for at-depth-to-register/n2/%rR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       9
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         at-depth-to-register/n2/%rR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "at-depth-to-register"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "at-depth-to-register/n2/%rR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME at_mdepth_mto_mregister__n2___rrR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is not branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is not branching: undefine branch
       macros so that they cannot be used by mistake. */
/* Locally poison JITTER_COMPUTED_GOTO . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_COMPUTED_GOTO")
# undef JITTER_COMPUTED_GOTO
# define JITTER_COMPUTED_GOTO JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_COMPUTED_GOTO, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_COMPUTED_GOTO
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_COMPUTED_GOTO . */

/* Locally poison JITTER_BRANCH . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_BRANCH")
# undef JITTER_BRANCH
# define JITTER_BRANCH JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_BRANCH, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_BRANCH
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_BRANCH . */

/* Locally poison JITTER_EXIT . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_EXIT")
# undef JITTER_EXIT
# define JITTER_EXIT JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_EXIT, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_EXIT
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_EXIT . */

  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1

    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 2L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a slow (therefore residual, passed as an offset)
        register. */
  /* Define a macro expanding to the slow register offset. */
#if defined(JITTER_DISPATCH_NO_THREADING)
# define JITTER_SLOW_REGISTER_OFFSET1 (JITTER_RESIDUAL_ARGUMENT_0.fixnum)
#elif defined (JITTER_DISPATCH_MINIMAL_THREADING)
# define JITTER_SLOW_REGISTER_OFFSET1 ((((union jitter_word*)jitter_ip)[0]).fixnum)
#else
# define JITTER_SLOW_REGISTER_OFFSET1 ((((union jitter_word*)jitter_ip)[1]).fixnum)
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
  /* Define a macro expanding to an l-value for the VM register content. */
#   define JITTER_ARG1  JITTER_SLOW_REGISTER_FROM_OFFSET(r, JITTER_SLOW_REGISTER_OFFSET1)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1


#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of at-depth-to-register/n2/%rR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "at-depth-to-register/n2/%rR"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for at-depth-to-register/n2/%rR . */
  {
/* User-specified code, user code block part: beginning. */

    // FIXME: replace with JITTER_AT_DEPTH_UNSAFE_MAINSTACK after I implement
    // unsafe at-depth operations.
    JITTER_ARG1 = JITTER_AT_DEPTH_MAINSTACK(JITTER_ARGN0);
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for at-depth-to-register/n2/%rR . */

  //fprintf (stderr, "..Executed instruction %s\n", "at-depth-to-register/n2/%rR");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the at-depth-to-register/n2/%rR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_EXIT")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_BRANCH")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_COMPUTED_GOTO")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(at-depth-to-register/n2/%rR, at_mdepth_mto_mregister__n2___rrR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for at-depth-to-register/n2/%rR, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction at-depth-to-register/n3/%rR */
  JITTER_INSTRUCTION_PROLOG_(at-depth-to-register/n3/%rR, at_mdepth_mto_mregister__n3___rrR, cold)
  { /* This block begins with definitions for at-depth-to-register/n3/%rR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       10
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         at-depth-to-register/n3/%rR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "at-depth-to-register"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "at-depth-to-register/n3/%rR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME at_mdepth_mto_mregister__n3___rrR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is not branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is not branching: undefine branch
       macros so that they cannot be used by mistake. */
/* Locally poison JITTER_COMPUTED_GOTO . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_COMPUTED_GOTO")
# undef JITTER_COMPUTED_GOTO
# define JITTER_COMPUTED_GOTO JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_COMPUTED_GOTO, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_COMPUTED_GOTO
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_COMPUTED_GOTO . */

/* Locally poison JITTER_BRANCH . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_BRANCH")
# undef JITTER_BRANCH
# define JITTER_BRANCH JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_BRANCH, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_BRANCH
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_BRANCH . */

/* Locally poison JITTER_EXIT . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_EXIT")
# undef JITTER_EXIT
# define JITTER_EXIT JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_EXIT, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_EXIT
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_EXIT . */

  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1

    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 3L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a slow (therefore residual, passed as an offset)
        register. */
  /* Define a macro expanding to the slow register offset. */
#if defined(JITTER_DISPATCH_NO_THREADING)
# define JITTER_SLOW_REGISTER_OFFSET1 (JITTER_RESIDUAL_ARGUMENT_0.fixnum)
#elif defined (JITTER_DISPATCH_MINIMAL_THREADING)
# define JITTER_SLOW_REGISTER_OFFSET1 ((((union jitter_word*)jitter_ip)[0]).fixnum)
#else
# define JITTER_SLOW_REGISTER_OFFSET1 ((((union jitter_word*)jitter_ip)[1]).fixnum)
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
  /* Define a macro expanding to an l-value for the VM register content. */
#   define JITTER_ARG1  JITTER_SLOW_REGISTER_FROM_OFFSET(r, JITTER_SLOW_REGISTER_OFFSET1)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1


#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of at-depth-to-register/n3/%rR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "at-depth-to-register/n3/%rR"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for at-depth-to-register/n3/%rR . */
  {
/* User-specified code, user code block part: beginning. */

    // FIXME: replace with JITTER_AT_DEPTH_UNSAFE_MAINSTACK after I implement
    // unsafe at-depth operations.
    JITTER_ARG1 = JITTER_AT_DEPTH_MAINSTACK(JITTER_ARGN0);
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for at-depth-to-register/n3/%rR . */

  //fprintf (stderr, "..Executed instruction %s\n", "at-depth-to-register/n3/%rR");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the at-depth-to-register/n3/%rR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_EXIT")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_BRANCH")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_COMPUTED_GOTO")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(at-depth-to-register/n3/%rR, at_mdepth_mto_mregister__n3___rrR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for at-depth-to-register/n3/%rR, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction at-depth-to-register/n4/%rR */
  JITTER_INSTRUCTION_PROLOG_(at-depth-to-register/n4/%rR, at_mdepth_mto_mregister__n4___rrR, cold)
  { /* This block begins with definitions for at-depth-to-register/n4/%rR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       11
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         at-depth-to-register/n4/%rR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "at-depth-to-register"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "at-depth-to-register/n4/%rR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME at_mdepth_mto_mregister__n4___rrR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is not branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is not branching: undefine branch
       macros so that they cannot be used by mistake. */
/* Locally poison JITTER_COMPUTED_GOTO . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_COMPUTED_GOTO")
# undef JITTER_COMPUTED_GOTO
# define JITTER_COMPUTED_GOTO JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_COMPUTED_GOTO, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_COMPUTED_GOTO
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_COMPUTED_GOTO . */

/* Locally poison JITTER_BRANCH . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_BRANCH")
# undef JITTER_BRANCH
# define JITTER_BRANCH JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_BRANCH, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_BRANCH
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_BRANCH . */

/* Locally poison JITTER_EXIT . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_EXIT")
# undef JITTER_EXIT
# define JITTER_EXIT JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_EXIT, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_EXIT
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_EXIT . */

  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1

    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 4L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a slow (therefore residual, passed as an offset)
        register. */
  /* Define a macro expanding to the slow register offset. */
#if defined(JITTER_DISPATCH_NO_THREADING)
# define JITTER_SLOW_REGISTER_OFFSET1 (JITTER_RESIDUAL_ARGUMENT_0.fixnum)
#elif defined (JITTER_DISPATCH_MINIMAL_THREADING)
# define JITTER_SLOW_REGISTER_OFFSET1 ((((union jitter_word*)jitter_ip)[0]).fixnum)
#else
# define JITTER_SLOW_REGISTER_OFFSET1 ((((union jitter_word*)jitter_ip)[1]).fixnum)
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
  /* Define a macro expanding to an l-value for the VM register content. */
#   define JITTER_ARG1  JITTER_SLOW_REGISTER_FROM_OFFSET(r, JITTER_SLOW_REGISTER_OFFSET1)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1


#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of at-depth-to-register/n4/%rR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "at-depth-to-register/n4/%rR"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for at-depth-to-register/n4/%rR . */
  {
/* User-specified code, user code block part: beginning. */

    // FIXME: replace with JITTER_AT_DEPTH_UNSAFE_MAINSTACK after I implement
    // unsafe at-depth operations.
    JITTER_ARG1 = JITTER_AT_DEPTH_MAINSTACK(JITTER_ARGN0);
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for at-depth-to-register/n4/%rR . */

  //fprintf (stderr, "..Executed instruction %s\n", "at-depth-to-register/n4/%rR");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the at-depth-to-register/n4/%rR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_EXIT")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_BRANCH")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_COMPUTED_GOTO")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(at-depth-to-register/n4/%rR, at_mdepth_mto_mregister__n4___rrR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for at-depth-to-register/n4/%rR, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction at-depth-to-register/n5/%rR */
  JITTER_INSTRUCTION_PROLOG_(at-depth-to-register/n5/%rR, at_mdepth_mto_mregister__n5___rrR, cold)
  { /* This block begins with definitions for at-depth-to-register/n5/%rR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       12
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         at-depth-to-register/n5/%rR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "at-depth-to-register"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "at-depth-to-register/n5/%rR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME at_mdepth_mto_mregister__n5___rrR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is not branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is not branching: undefine branch
       macros so that they cannot be used by mistake. */
/* Locally poison JITTER_COMPUTED_GOTO . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_COMPUTED_GOTO")
# undef JITTER_COMPUTED_GOTO
# define JITTER_COMPUTED_GOTO JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_COMPUTED_GOTO, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_COMPUTED_GOTO
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_COMPUTED_GOTO . */

/* Locally poison JITTER_BRANCH . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_BRANCH")
# undef JITTER_BRANCH
# define JITTER_BRANCH JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_BRANCH, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_BRANCH
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_BRANCH . */

/* Locally poison JITTER_EXIT . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_EXIT")
# undef JITTER_EXIT
# define JITTER_EXIT JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_EXIT, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_EXIT
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_EXIT . */

  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1

    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 5L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a slow (therefore residual, passed as an offset)
        register. */
  /* Define a macro expanding to the slow register offset. */
#if defined(JITTER_DISPATCH_NO_THREADING)
# define JITTER_SLOW_REGISTER_OFFSET1 (JITTER_RESIDUAL_ARGUMENT_0.fixnum)
#elif defined (JITTER_DISPATCH_MINIMAL_THREADING)
# define JITTER_SLOW_REGISTER_OFFSET1 ((((union jitter_word*)jitter_ip)[0]).fixnum)
#else
# define JITTER_SLOW_REGISTER_OFFSET1 ((((union jitter_word*)jitter_ip)[1]).fixnum)
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
  /* Define a macro expanding to an l-value for the VM register content. */
#   define JITTER_ARG1  JITTER_SLOW_REGISTER_FROM_OFFSET(r, JITTER_SLOW_REGISTER_OFFSET1)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1


#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of at-depth-to-register/n5/%rR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "at-depth-to-register/n5/%rR"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for at-depth-to-register/n5/%rR . */
  {
/* User-specified code, user code block part: beginning. */

    // FIXME: replace with JITTER_AT_DEPTH_UNSAFE_MAINSTACK after I implement
    // unsafe at-depth operations.
    JITTER_ARG1 = JITTER_AT_DEPTH_MAINSTACK(JITTER_ARGN0);
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for at-depth-to-register/n5/%rR . */

  //fprintf (stderr, "..Executed instruction %s\n", "at-depth-to-register/n5/%rR");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the at-depth-to-register/n5/%rR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_EXIT")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_BRANCH")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_COMPUTED_GOTO")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(at-depth-to-register/n5/%rR, at_mdepth_mto_mregister__n5___rrR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for at-depth-to-register/n5/%rR, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction at-depth-to-register/n6/%rR */
  JITTER_INSTRUCTION_PROLOG_(at-depth-to-register/n6/%rR, at_mdepth_mto_mregister__n6___rrR, cold)
  { /* This block begins with definitions for at-depth-to-register/n6/%rR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       13
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         at-depth-to-register/n6/%rR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "at-depth-to-register"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "at-depth-to-register/n6/%rR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME at_mdepth_mto_mregister__n6___rrR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is not branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is not branching: undefine branch
       macros so that they cannot be used by mistake. */
/* Locally poison JITTER_COMPUTED_GOTO . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_COMPUTED_GOTO")
# undef JITTER_COMPUTED_GOTO
# define JITTER_COMPUTED_GOTO JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_COMPUTED_GOTO, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_COMPUTED_GOTO
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_COMPUTED_GOTO . */

/* Locally poison JITTER_BRANCH . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_BRANCH")
# undef JITTER_BRANCH
# define JITTER_BRANCH JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_BRANCH, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_BRANCH
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_BRANCH . */

/* Locally poison JITTER_EXIT . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_EXIT")
# undef JITTER_EXIT
# define JITTER_EXIT JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_EXIT, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_EXIT
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_EXIT . */

  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1

    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 6L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a slow (therefore residual, passed as an offset)
        register. */
  /* Define a macro expanding to the slow register offset. */
#if defined(JITTER_DISPATCH_NO_THREADING)
# define JITTER_SLOW_REGISTER_OFFSET1 (JITTER_RESIDUAL_ARGUMENT_0.fixnum)
#elif defined (JITTER_DISPATCH_MINIMAL_THREADING)
# define JITTER_SLOW_REGISTER_OFFSET1 ((((union jitter_word*)jitter_ip)[0]).fixnum)
#else
# define JITTER_SLOW_REGISTER_OFFSET1 ((((union jitter_word*)jitter_ip)[1]).fixnum)
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
  /* Define a macro expanding to an l-value for the VM register content. */
#   define JITTER_ARG1  JITTER_SLOW_REGISTER_FROM_OFFSET(r, JITTER_SLOW_REGISTER_OFFSET1)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1


#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of at-depth-to-register/n6/%rR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "at-depth-to-register/n6/%rR"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for at-depth-to-register/n6/%rR . */
  {
/* User-specified code, user code block part: beginning. */

    // FIXME: replace with JITTER_AT_DEPTH_UNSAFE_MAINSTACK after I implement
    // unsafe at-depth operations.
    JITTER_ARG1 = JITTER_AT_DEPTH_MAINSTACK(JITTER_ARGN0);
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for at-depth-to-register/n6/%rR . */

  //fprintf (stderr, "..Executed instruction %s\n", "at-depth-to-register/n6/%rR");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the at-depth-to-register/n6/%rR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_EXIT")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_BRANCH")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_COMPUTED_GOTO")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(at-depth-to-register/n6/%rR, at_mdepth_mto_mregister__n6___rrR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for at-depth-to-register/n6/%rR, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction at-depth-to-register/n7/%rR */
  JITTER_INSTRUCTION_PROLOG_(at-depth-to-register/n7/%rR, at_mdepth_mto_mregister__n7___rrR, cold)
  { /* This block begins with definitions for at-depth-to-register/n7/%rR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       14
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         at-depth-to-register/n7/%rR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "at-depth-to-register"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "at-depth-to-register/n7/%rR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME at_mdepth_mto_mregister__n7___rrR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is not branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is not branching: undefine branch
       macros so that they cannot be used by mistake. */
/* Locally poison JITTER_COMPUTED_GOTO . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_COMPUTED_GOTO")
# undef JITTER_COMPUTED_GOTO
# define JITTER_COMPUTED_GOTO JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_COMPUTED_GOTO, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_COMPUTED_GOTO
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_COMPUTED_GOTO . */

/* Locally poison JITTER_BRANCH . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_BRANCH")
# undef JITTER_BRANCH
# define JITTER_BRANCH JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_BRANCH, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_BRANCH
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_BRANCH . */

/* Locally poison JITTER_EXIT . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_EXIT")
# undef JITTER_EXIT
# define JITTER_EXIT JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_EXIT, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_EXIT
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_EXIT . */

  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1

    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 7L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a slow (therefore residual, passed as an offset)
        register. */
  /* Define a macro expanding to the slow register offset. */
#if defined(JITTER_DISPATCH_NO_THREADING)
# define JITTER_SLOW_REGISTER_OFFSET1 (JITTER_RESIDUAL_ARGUMENT_0.fixnum)
#elif defined (JITTER_DISPATCH_MINIMAL_THREADING)
# define JITTER_SLOW_REGISTER_OFFSET1 ((((union jitter_word*)jitter_ip)[0]).fixnum)
#else
# define JITTER_SLOW_REGISTER_OFFSET1 ((((union jitter_word*)jitter_ip)[1]).fixnum)
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
  /* Define a macro expanding to an l-value for the VM register content. */
#   define JITTER_ARG1  JITTER_SLOW_REGISTER_FROM_OFFSET(r, JITTER_SLOW_REGISTER_OFFSET1)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1


#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of at-depth-to-register/n7/%rR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "at-depth-to-register/n7/%rR"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for at-depth-to-register/n7/%rR . */
  {
/* User-specified code, user code block part: beginning. */

    // FIXME: replace with JITTER_AT_DEPTH_UNSAFE_MAINSTACK after I implement
    // unsafe at-depth operations.
    JITTER_ARG1 = JITTER_AT_DEPTH_MAINSTACK(JITTER_ARGN0);
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for at-depth-to-register/n7/%rR . */

  //fprintf (stderr, "..Executed instruction %s\n", "at-depth-to-register/n7/%rR");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the at-depth-to-register/n7/%rR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_EXIT")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_BRANCH")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_COMPUTED_GOTO")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(at-depth-to-register/n7/%rR, at_mdepth_mto_mregister__n7___rrR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for at-depth-to-register/n7/%rR, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction at-depth-to-register/n8/%rR */
  JITTER_INSTRUCTION_PROLOG_(at-depth-to-register/n8/%rR, at_mdepth_mto_mregister__n8___rrR, cold)
  { /* This block begins with definitions for at-depth-to-register/n8/%rR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       15
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         at-depth-to-register/n8/%rR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "at-depth-to-register"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "at-depth-to-register/n8/%rR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME at_mdepth_mto_mregister__n8___rrR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is not branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is not branching: undefine branch
       macros so that they cannot be used by mistake. */
/* Locally poison JITTER_COMPUTED_GOTO . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_COMPUTED_GOTO")
# undef JITTER_COMPUTED_GOTO
# define JITTER_COMPUTED_GOTO JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_COMPUTED_GOTO, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_COMPUTED_GOTO
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_COMPUTED_GOTO . */

/* Locally poison JITTER_BRANCH . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_BRANCH")
# undef JITTER_BRANCH
# define JITTER_BRANCH JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_BRANCH, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_BRANCH
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_BRANCH . */

/* Locally poison JITTER_EXIT . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_EXIT")
# undef JITTER_EXIT
# define JITTER_EXIT JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_EXIT, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_EXIT
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_EXIT . */

  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1

    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 8L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a slow (therefore residual, passed as an offset)
        register. */
  /* Define a macro expanding to the slow register offset. */
#if defined(JITTER_DISPATCH_NO_THREADING)
# define JITTER_SLOW_REGISTER_OFFSET1 (JITTER_RESIDUAL_ARGUMENT_0.fixnum)
#elif defined (JITTER_DISPATCH_MINIMAL_THREADING)
# define JITTER_SLOW_REGISTER_OFFSET1 ((((union jitter_word*)jitter_ip)[0]).fixnum)
#else
# define JITTER_SLOW_REGISTER_OFFSET1 ((((union jitter_word*)jitter_ip)[1]).fixnum)
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
  /* Define a macro expanding to an l-value for the VM register content. */
#   define JITTER_ARG1  JITTER_SLOW_REGISTER_FROM_OFFSET(r, JITTER_SLOW_REGISTER_OFFSET1)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1


#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of at-depth-to-register/n8/%rR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "at-depth-to-register/n8/%rR"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for at-depth-to-register/n8/%rR . */
  {
/* User-specified code, user code block part: beginning. */

    // FIXME: replace with JITTER_AT_DEPTH_UNSAFE_MAINSTACK after I implement
    // unsafe at-depth operations.
    JITTER_ARG1 = JITTER_AT_DEPTH_MAINSTACK(JITTER_ARGN0);
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for at-depth-to-register/n8/%rR . */

  //fprintf (stderr, "..Executed instruction %s\n", "at-depth-to-register/n8/%rR");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the at-depth-to-register/n8/%rR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_EXIT")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_BRANCH")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_COMPUTED_GOTO")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(at-depth-to-register/n8/%rR, at_mdepth_mto_mregister__n8___rrR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for at-depth-to-register/n8/%rR, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction at-depth-to-register/n9/%rR */
  JITTER_INSTRUCTION_PROLOG_(at-depth-to-register/n9/%rR, at_mdepth_mto_mregister__n9___rrR, cold)
  { /* This block begins with definitions for at-depth-to-register/n9/%rR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       16
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         at-depth-to-register/n9/%rR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "at-depth-to-register"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "at-depth-to-register/n9/%rR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME at_mdepth_mto_mregister__n9___rrR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is not branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is not branching: undefine branch
       macros so that they cannot be used by mistake. */
/* Locally poison JITTER_COMPUTED_GOTO . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_COMPUTED_GOTO")
# undef JITTER_COMPUTED_GOTO
# define JITTER_COMPUTED_GOTO JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_COMPUTED_GOTO, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_COMPUTED_GOTO
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_COMPUTED_GOTO . */

/* Locally poison JITTER_BRANCH . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_BRANCH")
# undef JITTER_BRANCH
# define JITTER_BRANCH JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_BRANCH, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_BRANCH
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_BRANCH . */

/* Locally poison JITTER_EXIT . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_EXIT")
# undef JITTER_EXIT
# define JITTER_EXIT JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_EXIT, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_EXIT
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_EXIT . */

  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1

    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 9L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a slow (therefore residual, passed as an offset)
        register. */
  /* Define a macro expanding to the slow register offset. */
#if defined(JITTER_DISPATCH_NO_THREADING)
# define JITTER_SLOW_REGISTER_OFFSET1 (JITTER_RESIDUAL_ARGUMENT_0.fixnum)
#elif defined (JITTER_DISPATCH_MINIMAL_THREADING)
# define JITTER_SLOW_REGISTER_OFFSET1 ((((union jitter_word*)jitter_ip)[0]).fixnum)
#else
# define JITTER_SLOW_REGISTER_OFFSET1 ((((union jitter_word*)jitter_ip)[1]).fixnum)
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
  /* Define a macro expanding to an l-value for the VM register content. */
#   define JITTER_ARG1  JITTER_SLOW_REGISTER_FROM_OFFSET(r, JITTER_SLOW_REGISTER_OFFSET1)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1


#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of at-depth-to-register/n9/%rR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "at-depth-to-register/n9/%rR"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for at-depth-to-register/n9/%rR . */
  {
/* User-specified code, user code block part: beginning. */

    // FIXME: replace with JITTER_AT_DEPTH_UNSAFE_MAINSTACK after I implement
    // unsafe at-depth operations.
    JITTER_ARG1 = JITTER_AT_DEPTH_MAINSTACK(JITTER_ARGN0);
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for at-depth-to-register/n9/%rR . */

  //fprintf (stderr, "..Executed instruction %s\n", "at-depth-to-register/n9/%rR");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the at-depth-to-register/n9/%rR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_EXIT")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_BRANCH")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_COMPUTED_GOTO")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(at-depth-to-register/n9/%rR, at_mdepth_mto_mregister__n9___rrR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for at-depth-to-register/n9/%rR, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction at-depth-to-register/n10/%rR */
  JITTER_INSTRUCTION_PROLOG_(at-depth-to-register/n10/%rR, at_mdepth_mto_mregister__n10___rrR, cold)
  { /* This block begins with definitions for at-depth-to-register/n10/%rR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       17
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         at-depth-to-register/n10/%rR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "at-depth-to-register"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "at-depth-to-register/n10/%rR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME at_mdepth_mto_mregister__n10___rrR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is not branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is not branching: undefine branch
       macros so that they cannot be used by mistake. */
/* Locally poison JITTER_COMPUTED_GOTO . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_COMPUTED_GOTO")
# undef JITTER_COMPUTED_GOTO
# define JITTER_COMPUTED_GOTO JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_COMPUTED_GOTO, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_COMPUTED_GOTO
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_COMPUTED_GOTO . */

/* Locally poison JITTER_BRANCH . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_BRANCH")
# undef JITTER_BRANCH
# define JITTER_BRANCH JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_BRANCH, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_BRANCH
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_BRANCH . */

/* Locally poison JITTER_EXIT . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_EXIT")
# undef JITTER_EXIT
# define JITTER_EXIT JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_EXIT, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_EXIT
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_EXIT . */

  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1

    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 10L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a slow (therefore residual, passed as an offset)
        register. */
  /* Define a macro expanding to the slow register offset. */
#if defined(JITTER_DISPATCH_NO_THREADING)
# define JITTER_SLOW_REGISTER_OFFSET1 (JITTER_RESIDUAL_ARGUMENT_0.fixnum)
#elif defined (JITTER_DISPATCH_MINIMAL_THREADING)
# define JITTER_SLOW_REGISTER_OFFSET1 ((((union jitter_word*)jitter_ip)[0]).fixnum)
#else
# define JITTER_SLOW_REGISTER_OFFSET1 ((((union jitter_word*)jitter_ip)[1]).fixnum)
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
  /* Define a macro expanding to an l-value for the VM register content. */
#   define JITTER_ARG1  JITTER_SLOW_REGISTER_FROM_OFFSET(r, JITTER_SLOW_REGISTER_OFFSET1)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1


#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of at-depth-to-register/n10/%rR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "at-depth-to-register/n10/%rR"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for at-depth-to-register/n10/%rR . */
  {
/* User-specified code, user code block part: beginning. */

    // FIXME: replace with JITTER_AT_DEPTH_UNSAFE_MAINSTACK after I implement
    // unsafe at-depth operations.
    JITTER_ARG1 = JITTER_AT_DEPTH_MAINSTACK(JITTER_ARGN0);
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for at-depth-to-register/n10/%rR . */

  //fprintf (stderr, "..Executed instruction %s\n", "at-depth-to-register/n10/%rR");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the at-depth-to-register/n10/%rR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_EXIT")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_BRANCH")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_COMPUTED_GOTO")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(at-depth-to-register/n10/%rR, at_mdepth_mto_mregister__n10___rrR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for at-depth-to-register/n10/%rR, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction at-depth-to-register/nR/%rR */
  JITTER_INSTRUCTION_PROLOG_(at-depth-to-register/nR/%rR, at_mdepth_mto_mregister__nR___rrR, cold)
  { /* This block begins with definitions for at-depth-to-register/nR/%rR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       18
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         at-depth-to-register/nR/%rR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "at-depth-to-register"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "at-depth-to-register/nR/%rR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME at_mdepth_mto_mregister__nR___rrR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is not branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is not branching: undefine branch
       macros so that they cannot be used by mistake. */
/* Locally poison JITTER_COMPUTED_GOTO . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_COMPUTED_GOTO")
# undef JITTER_COMPUTED_GOTO
# define JITTER_COMPUTED_GOTO JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_COMPUTED_GOTO, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_COMPUTED_GOTO
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_COMPUTED_GOTO . */

/* Locally poison JITTER_BRANCH . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_BRANCH")
# undef JITTER_BRANCH
# define JITTER_BRANCH JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_BRANCH, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_BRANCH
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_BRANCH . */

/* Locally poison JITTER_EXIT . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_EXIT")
# undef JITTER_EXIT
# define JITTER_EXIT JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_EXIT, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_EXIT
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_EXIT . */

  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 2

    /* The 0th argument is a residual literal. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a slow (therefore residual, passed as an offset)
        register. */
  /* Define a macro expanding to the slow register offset. */
#if defined(JITTER_DISPATCH_NO_THREADING)
# define JITTER_SLOW_REGISTER_OFFSET1 (JITTER_RESIDUAL_ARGUMENT_1.fixnum)
#elif defined (JITTER_DISPATCH_MINIMAL_THREADING)
# define JITTER_SLOW_REGISTER_OFFSET1 ((((union jitter_word*)jitter_ip)[1]).fixnum)
#else
# define JITTER_SLOW_REGISTER_OFFSET1 ((((union jitter_word*)jitter_ip)[2]).fixnum)
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
  /* Define a macro expanding to an l-value for the VM register content. */
#   define JITTER_ARG1  JITTER_SLOW_REGISTER_FROM_OFFSET(r, JITTER_SLOW_REGISTER_OFFSET1)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1


#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of at-depth-to-register/nR/%rR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "at-depth-to-register/nR/%rR"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for at-depth-to-register/nR/%rR . */
  {
/* User-specified code, user code block part: beginning. */

    // FIXME: replace with JITTER_AT_DEPTH_UNSAFE_MAINSTACK after I implement
    // unsafe at-depth operations.
    JITTER_ARG1 = JITTER_AT_DEPTH_MAINSTACK(JITTER_ARGN0);
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for at-depth-to-register/nR/%rR . */

  //fprintf (stderr, "..Executed instruction %s\n", "at-depth-to-register/nR/%rR");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the at-depth-to-register/nR/%rR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_EXIT")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_BRANCH")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_COMPUTED_GOTO")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(at-depth-to-register/nR/%rR, at_mdepth_mto_mregister__nR___rrR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for at-depth-to-register/nR/%rR, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction branch/fR */
  JITTER_INSTRUCTION_PROLOG_(branch/fR, branch__fR, hot)
  { /* This block begins with definitions for branch/fR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       19
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         branch/fR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "branch"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "branch/fR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME branch__fR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity varies depending on whether we have fast labels. */
#ifdef JITTER_HAVE_PATCH_IN
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
#else
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
#endif // #ifdef JITTER_HAVE_PATCH_IN

  /* Define argument-access macros for branch/fR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a "residual" fast label.  Define its
       _ARGF macro as the residual *index* (counting only fast labels, 0-based),
       so that at replication time we know what instruction address to patch in. */
#   define JITTER_ARGF0 0
    /* JITTER_ARG0 is intentionally not defined for a fast label. */

#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of branch/fR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "branch/fR"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for branch/fR . */
  {
/* User-specified code, user code block part: beginning. */

    JITTER_BRANCH_FAST(JITTER_ARGF0);
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for branch/fR . */

  //fprintf (stderr, "..Executed instruction %s\n", "branch/fR");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the branch/fR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(branch/fR, branch__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for branch/fR, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction branch-if-false/fR */
  JITTER_INSTRUCTION_PROLOG_(branch-if-false/fR, branch_mif_mfalse__fR, hot)
  { /* This block begins with definitions for branch-if-false/fR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       20
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         branch-if-false/fR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "branch-if-false"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "branch-if-false/fR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME branch_mif_mfalse__fR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity varies depending on whether we have fast labels. */
#ifdef JITTER_HAVE_PATCH_IN
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
#else
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
#endif // #ifdef JITTER_HAVE_PATCH_IN

  /* Define argument-access macros for branch-if-false/fR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a "residual" fast label.  Define its
       _ARGF macro as the residual *index* (counting only fast labels, 0-based),
       so that at replication time we know what instruction address to patch in. */
#   define JITTER_ARGF0 0
    /* JITTER_ARG0 is intentionally not defined for a fast label. */

#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of branch-if-false/fR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "branch-if-false/fR"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for branch-if-false/fR . */
  {
/* User-specified code, user code block part: beginning. */

    jitterlisp_object top = JITTER_TOP_MAINSTACK();
    JITTER_DROP_MAINSTACK();
    JITTER_BRANCH_FAST_IF_EQUAL(top, JITTERLISP_FALSE, JITTER_ARGF0);
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for branch-if-false/fR . */

  //fprintf (stderr, "..Executed instruction %s\n", "branch-if-false/fR");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the branch-if-false/fR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(branch-if-false/fR, branch_mif_mfalse__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for branch-if-false/fR, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction branch-if-non-positive/fR/fR */
  JITTER_INSTRUCTION_PROLOG_(branch-if-non-positive/fR/fR, branch_mif_mnon_mpositive__fR__fR, hot)
  { /* This block begins with definitions for branch-if-non-positive/fR/fR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       21
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         branch-if-non-positive/fR/fR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "branch-if-non-positive"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "branch-if-non-positive/fR/fR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME branch_mif_mnon_mpositive__fR__fR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity varies depending on whether we have fast labels. */
#ifdef JITTER_HAVE_PATCH_IN
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
#else
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 2
#endif // #ifdef JITTER_HAVE_PATCH_IN

  /* Define argument-access macros for branch-if-non-positive/fR/fR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a "residual" fast label.  Define its
       _ARGF macro as the residual *index* (counting only fast labels, 0-based),
       so that at replication time we know what instruction address to patch in. */
#   define JITTER_ARGF0 0
    /* JITTER_ARG0 is intentionally not defined for a fast label. */

#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)

    /* The 1th argument is a "residual" fast label.  Define its
       _ARGF macro as the residual *index* (counting only fast labels, 0-based),
       so that at replication time we know what instruction address to patch in. */
#   define JITTER_ARGF1 1
    /* JITTER_ARG1 is intentionally not defined for a fast label. */

#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of branch-if-non-positive/fR/fR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "branch-if-non-positive/fR/fR"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for branch-if-non-positive/fR/fR . */
  {
/* User-specified code, user code block part: beginning. */

    JITTERLISPVM_CHECK_TYPES_1(FIXNUM, JITTER_ARGF1);
    jitterlisp_object top = JITTER_TOP_MAINSTACK();
    JITTER_DROP_MAINSTACK();
    JITTER_BRANCH_FAST_IF_NONPOSITIVE(top, JITTER_ARGF0);
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for branch-if-non-positive/fR/fR . */

  //fprintf (stderr, "..Executed instruction %s\n", "branch-if-non-positive/fR/fR");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the branch-if-non-positive/fR/fR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(branch-if-non-positive/fR/fR, branch_mif_mnon_mpositive__fR__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for branch-if-non-positive/fR/fR, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction branch-if-not-less/fR/fR */
  JITTER_INSTRUCTION_PROLOG_(branch-if-not-less/fR/fR, branch_mif_mnot_mless__fR__fR, hot)
  { /* This block begins with definitions for branch-if-not-less/fR/fR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       22
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         branch-if-not-less/fR/fR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "branch-if-not-less"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "branch-if-not-less/fR/fR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME branch_mif_mnot_mless__fR__fR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity varies depending on whether we have fast labels. */
#ifdef JITTER_HAVE_PATCH_IN
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
#else
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 2
#endif // #ifdef JITTER_HAVE_PATCH_IN

  /* Define argument-access macros for branch-if-not-less/fR/fR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a "residual" fast label.  Define its
       _ARGF macro as the residual *index* (counting only fast labels, 0-based),
       so that at replication time we know what instruction address to patch in. */
#   define JITTER_ARGF0 0
    /* JITTER_ARG0 is intentionally not defined for a fast label. */

#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)

    /* The 1th argument is a "residual" fast label.  Define its
       _ARGF macro as the residual *index* (counting only fast labels, 0-based),
       so that at replication time we know what instruction address to patch in. */
#   define JITTER_ARGF1 1
    /* JITTER_ARG1 is intentionally not defined for a fast label. */

#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of branch-if-not-less/fR/fR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "branch-if-not-less/fR/fR"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for branch-if-not-less/fR/fR . */
  {
/* User-specified code, user code block part: beginning. */

    JITTERLISPVM_CHECK_TYPES_2(FIXNUM, FIXNUM, JITTER_ARGF1);
    jitterlisp_object undertop = JITTER_UNDER_TOP_MAINSTACK();
    jitterlisp_object top = JITTER_TOP_MAINSTACK();
    JITTER_NIP_MAINSTACK();
    JITTER_DROP_MAINSTACK();
    JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED(undertop, top, JITTER_ARGF0);
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for branch-if-not-less/fR/fR . */

  //fprintf (stderr, "..Executed instruction %s\n", "branch-if-not-less/fR/fR");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the branch-if-not-less/fR/fR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(branch-if-not-less/fR/fR, branch_mif_mnot_mless__fR__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for branch-if-not-less/fR/fR, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction branch-if-not-null/fR */
  JITTER_INSTRUCTION_PROLOG_(branch-if-not-null/fR, branch_mif_mnot_mnull__fR, hot)
  { /* This block begins with definitions for branch-if-not-null/fR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       23
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         branch-if-not-null/fR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "branch-if-not-null"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "branch-if-not-null/fR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME branch_mif_mnot_mnull__fR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity varies depending on whether we have fast labels. */
#ifdef JITTER_HAVE_PATCH_IN
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
#else
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
#endif // #ifdef JITTER_HAVE_PATCH_IN

  /* Define argument-access macros for branch-if-not-null/fR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a "residual" fast label.  Define its
       _ARGF macro as the residual *index* (counting only fast labels, 0-based),
       so that at replication time we know what instruction address to patch in. */
#   define JITTER_ARGF0 0
    /* JITTER_ARG0 is intentionally not defined for a fast label. */

#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of branch-if-not-null/fR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "branch-if-not-null/fR"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for branch-if-not-null/fR . */
  {
/* User-specified code, user code block part: beginning. */

    jitterlisp_object top = JITTER_TOP_MAINSTACK();
    JITTER_DROP_MAINSTACK();
    JITTER_BRANCH_FAST_IF_NOTEQUAL(top, JITTERLISP_EMPTY_LIST, JITTER_ARGF0);
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for branch-if-not-null/fR . */

  //fprintf (stderr, "..Executed instruction %s\n", "branch-if-not-null/fR");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the branch-if-not-null/fR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(branch-if-not-null/fR, branch_mif_mnot_mnull__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for branch-if-not-null/fR, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction branch-if-null/fR */
  JITTER_INSTRUCTION_PROLOG_(branch-if-null/fR, branch_mif_mnull__fR, hot)
  { /* This block begins with definitions for branch-if-null/fR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       24
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         branch-if-null/fR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "branch-if-null"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "branch-if-null/fR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME branch_mif_mnull__fR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity varies depending on whether we have fast labels. */
#ifdef JITTER_HAVE_PATCH_IN
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
#else
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
#endif // #ifdef JITTER_HAVE_PATCH_IN

  /* Define argument-access macros for branch-if-null/fR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a "residual" fast label.  Define its
       _ARGF macro as the residual *index* (counting only fast labels, 0-based),
       so that at replication time we know what instruction address to patch in. */
#   define JITTER_ARGF0 0
    /* JITTER_ARG0 is intentionally not defined for a fast label. */

#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of branch-if-null/fR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "branch-if-null/fR"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for branch-if-null/fR . */
  {
/* User-specified code, user code block part: beginning. */

    jitterlisp_object top = JITTER_TOP_MAINSTACK();
    JITTER_DROP_MAINSTACK();
    JITTER_BRANCH_FAST_IF_EQUAL(top, JITTERLISP_EMPTY_LIST, JITTER_ARGF0);
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for branch-if-null/fR . */

  //fprintf (stderr, "..Executed instruction %s\n", "branch-if-null/fR");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the branch-if-null/fR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(branch-if-null/fR, branch_mif_mnull__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for branch-if-null/fR, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction branch-if-positive/fR/fR */
  JITTER_INSTRUCTION_PROLOG_(branch-if-positive/fR/fR, branch_mif_mpositive__fR__fR, hot)
  { /* This block begins with definitions for branch-if-positive/fR/fR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       25
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         branch-if-positive/fR/fR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "branch-if-positive"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "branch-if-positive/fR/fR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME branch_mif_mpositive__fR__fR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity varies depending on whether we have fast labels. */
#ifdef JITTER_HAVE_PATCH_IN
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
#else
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 2
#endif // #ifdef JITTER_HAVE_PATCH_IN

  /* Define argument-access macros for branch-if-positive/fR/fR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a "residual" fast label.  Define its
       _ARGF macro as the residual *index* (counting only fast labels, 0-based),
       so that at replication time we know what instruction address to patch in. */
#   define JITTER_ARGF0 0
    /* JITTER_ARG0 is intentionally not defined for a fast label. */

#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)

    /* The 1th argument is a "residual" fast label.  Define its
       _ARGF macro as the residual *index* (counting only fast labels, 0-based),
       so that at replication time we know what instruction address to patch in. */
#   define JITTER_ARGF1 1
    /* JITTER_ARG1 is intentionally not defined for a fast label. */

#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of branch-if-positive/fR/fR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "branch-if-positive/fR/fR"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for branch-if-positive/fR/fR . */
  {
/* User-specified code, user code block part: beginning. */

    JITTERLISPVM_CHECK_TYPES_1(FIXNUM, JITTER_ARGF1);
    jitterlisp_object top = JITTER_TOP_MAINSTACK();
    JITTER_DROP_MAINSTACK();
    JITTER_BRANCH_FAST_IF_POSITIVE(top, JITTER_ARGF0);
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for branch-if-positive/fR/fR . */

  //fprintf (stderr, "..Executed instruction %s\n", "branch-if-positive/fR/fR");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the branch-if-positive/fR/fR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(branch-if-positive/fR/fR, branch_mif_mpositive__fR__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for branch-if-positive/fR/fR, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction branch-if-register-non-positive/%rR/fR/fR */
  JITTER_INSTRUCTION_PROLOG_(branch-if-register-non-positive/%rR/fR/fR, branch_mif_mregister_mnon_mpositive___rrR__fR__fR, cold)
  { /* This block begins with definitions for branch-if-register-non-positive/%rR/fR/fR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       26
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         branch-if-register-non-positive/%rR/fR/fR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "branch-if-register-non-positive"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "branch-if-register-non-positive/%rR/fR/fR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME branch_mif_mregister_mnon_mpositive___rrR__fR__fR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity varies depending on whether we have fast labels. */
#ifdef JITTER_HAVE_PATCH_IN
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
#else
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 3
#endif // #ifdef JITTER_HAVE_PATCH_IN

  /* Define argument-access macros for branch-if-register-non-positive/%rR/fR/fR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a slow (therefore residual, passed as an offset)
        register. */
  /* Define a macro expanding to the slow register offset. */
#if defined(JITTER_DISPATCH_NO_THREADING)
# define JITTER_SLOW_REGISTER_OFFSET0 (JITTER_RESIDUAL_ARGUMENT_0.fixnum)
#elif defined (JITTER_DISPATCH_MINIMAL_THREADING)
# define JITTER_SLOW_REGISTER_OFFSET0 ((((union jitter_word*)jitter_ip)[0]).fixnum)
#else
# define JITTER_SLOW_REGISTER_OFFSET0 ((((union jitter_word*)jitter_ip)[1]).fixnum)
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
  /* Define a macro expanding to an l-value for the VM register content. */
#   define JITTER_ARG0  JITTER_SLOW_REGISTER_FROM_OFFSET(r, JITTER_SLOW_REGISTER_OFFSET0)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)

    /* The 1th argument is a "residual" fast label.  Define its
       _ARGF macro as the residual *index* (counting only fast labels, 0-based),
       so that at replication time we know what instruction address to patch in. */
#   define JITTER_ARGF1 0
    /* JITTER_ARG1 is intentionally not defined for a fast label. */

#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)

    /* The 2th argument is a "residual" fast label.  Define its
       _ARGF macro as the residual *index* (counting only fast labels, 0-based),
       so that at replication time we know what instruction address to patch in. */
#   define JITTER_ARGF2 1
    /* JITTER_ARG2 is intentionally not defined for a fast label. */

#   define JITTER_ARGN2 (JITTER_ARG2.fixnum)
#   define JITTER_ARGU2 (JITTER_ARG2.ufixnum)
#   define JITTER_ARGP2 (JITTER_ARG2.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
    /* The 0th argument is a slow (therefore residual, passed as an offset)
        register. */
  /* Define a macro expanding to the slow register offset. */
#if defined(JITTER_DISPATCH_NO_THREADING)
# define JITTER_SLOW_REGISTER_OFFSET0 (JITTER_RESIDUAL_ARGUMENT_0.fixnum)
#elif defined (JITTER_DISPATCH_MINIMAL_THREADING)
# define JITTER_SLOW_REGISTER_OFFSET0 ((((union jitter_word*)jitter_ip)[0]).fixnum)
#else
# define JITTER_SLOW_REGISTER_OFFSET0 ((((union jitter_word*)jitter_ip)[1]).fixnum)
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
  /* Define a macro expanding to an l-value for the VM register content. */
#   define JITTER_ARG0  JITTER_SLOW_REGISTER_FROM_OFFSET(r, JITTER_SLOW_REGISTER_OFFSET0)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG2  JITTER_RESIDUAL_ARGUMENT_2
    JITTER_MARK_RESIDUAL_2_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[2])
#else
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[3])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN2 (JITTER_ARG2.fixnum)
#   define JITTER_ARGU2 (JITTER_ARG2.ufixnum)
#   define JITTER_ARGP2 (JITTER_ARG2.pointer)
#   define JITTER_ARGF2 JITTER_ARGP2

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of branch-if-register-non-positive/%rR/fR/fR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "branch-if-register-non-positive/%rR/fR/fR"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for branch-if-register-non-positive/%rR/fR/fR . */
  {
/* User-specified code, user code block part: beginning. */

#if ! defined (JITTERLISP_UNSAFE)
    JITTERLISP_BRANCH_FAST_UNLESS_FIXNUM (JITTER_ARG0, JITTER_ARGF2);
#endif
    JITTER_BRANCH_FAST_IF_NONPOSITIVE(JITTER_ARG0, JITTER_ARGF1);
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for branch-if-register-non-positive/%rR/fR/fR . */

  //fprintf (stderr, "..Executed instruction %s\n", "branch-if-register-non-positive/%rR/fR/fR");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the branch-if-register-non-positive/%rR/fR/fR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1
#   undef JITTER_SLOW_REGISTER_OFFSET2
#   undef JITTER_ARG2
#   undef JITTER_ARGN2
#   undef JITTER_ARGU2
#   undef JITTER_ARGP2
#   undef JITTER_ARGF2

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(branch-if-register-non-positive/%rR/fR/fR, branch_mif_mregister_mnon_mpositive___rrR__fR__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for branch-if-register-non-positive/%rR/fR/fR, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction branch-if-register-non-zero/%rR/fR/fR */
  JITTER_INSTRUCTION_PROLOG_(branch-if-register-non-zero/%rR/fR/fR, branch_mif_mregister_mnon_mzero___rrR__fR__fR, cold)
  { /* This block begins with definitions for branch-if-register-non-zero/%rR/fR/fR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       27
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         branch-if-register-non-zero/%rR/fR/fR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "branch-if-register-non-zero"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "branch-if-register-non-zero/%rR/fR/fR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME branch_mif_mregister_mnon_mzero___rrR__fR__fR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity varies depending on whether we have fast labels. */
#ifdef JITTER_HAVE_PATCH_IN
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
#else
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 3
#endif // #ifdef JITTER_HAVE_PATCH_IN

  /* Define argument-access macros for branch-if-register-non-zero/%rR/fR/fR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a slow (therefore residual, passed as an offset)
        register. */
  /* Define a macro expanding to the slow register offset. */
#if defined(JITTER_DISPATCH_NO_THREADING)
# define JITTER_SLOW_REGISTER_OFFSET0 (JITTER_RESIDUAL_ARGUMENT_0.fixnum)
#elif defined (JITTER_DISPATCH_MINIMAL_THREADING)
# define JITTER_SLOW_REGISTER_OFFSET0 ((((union jitter_word*)jitter_ip)[0]).fixnum)
#else
# define JITTER_SLOW_REGISTER_OFFSET0 ((((union jitter_word*)jitter_ip)[1]).fixnum)
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
  /* Define a macro expanding to an l-value for the VM register content. */
#   define JITTER_ARG0  JITTER_SLOW_REGISTER_FROM_OFFSET(r, JITTER_SLOW_REGISTER_OFFSET0)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)

    /* The 1th argument is a "residual" fast label.  Define its
       _ARGF macro as the residual *index* (counting only fast labels, 0-based),
       so that at replication time we know what instruction address to patch in. */
#   define JITTER_ARGF1 0
    /* JITTER_ARG1 is intentionally not defined for a fast label. */

#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)

    /* The 2th argument is a "residual" fast label.  Define its
       _ARGF macro as the residual *index* (counting only fast labels, 0-based),
       so that at replication time we know what instruction address to patch in. */
#   define JITTER_ARGF2 1
    /* JITTER_ARG2 is intentionally not defined for a fast label. */

#   define JITTER_ARGN2 (JITTER_ARG2.fixnum)
#   define JITTER_ARGU2 (JITTER_ARG2.ufixnum)
#   define JITTER_ARGP2 (JITTER_ARG2.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
    /* The 0th argument is a slow (therefore residual, passed as an offset)
        register. */
  /* Define a macro expanding to the slow register offset. */
#if defined(JITTER_DISPATCH_NO_THREADING)
# define JITTER_SLOW_REGISTER_OFFSET0 (JITTER_RESIDUAL_ARGUMENT_0.fixnum)
#elif defined (JITTER_DISPATCH_MINIMAL_THREADING)
# define JITTER_SLOW_REGISTER_OFFSET0 ((((union jitter_word*)jitter_ip)[0]).fixnum)
#else
# define JITTER_SLOW_REGISTER_OFFSET0 ((((union jitter_word*)jitter_ip)[1]).fixnum)
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
  /* Define a macro expanding to an l-value for the VM register content. */
#   define JITTER_ARG0  JITTER_SLOW_REGISTER_FROM_OFFSET(r, JITTER_SLOW_REGISTER_OFFSET0)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG2  JITTER_RESIDUAL_ARGUMENT_2
    JITTER_MARK_RESIDUAL_2_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[2])
#else
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[3])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN2 (JITTER_ARG2.fixnum)
#   define JITTER_ARGU2 (JITTER_ARG2.ufixnum)
#   define JITTER_ARGP2 (JITTER_ARG2.pointer)
#   define JITTER_ARGF2 JITTER_ARGP2

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of branch-if-register-non-zero/%rR/fR/fR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "branch-if-register-non-zero/%rR/fR/fR"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for branch-if-register-non-zero/%rR/fR/fR . */
  {
/* User-specified code, user code block part: beginning. */

#if ! defined (JITTERLISP_UNSAFE)
    JITTERLISP_BRANCH_FAST_UNLESS_FIXNUM (JITTER_ARG0, JITTER_ARGF2);
#endif
    JITTER_BRANCH_FAST_IF_NOTEQUAL(JITTER_ARG0, JITTERLISP_FIXNUM_ENCODE(0),
                                   JITTER_ARGF1);
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for branch-if-register-non-zero/%rR/fR/fR . */

  //fprintf (stderr, "..Executed instruction %s\n", "branch-if-register-non-zero/%rR/fR/fR");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the branch-if-register-non-zero/%rR/fR/fR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1
#   undef JITTER_SLOW_REGISTER_OFFSET2
#   undef JITTER_ARG2
#   undef JITTER_ARGN2
#   undef JITTER_ARGU2
#   undef JITTER_ARGP2
#   undef JITTER_ARGF2

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(branch-if-register-non-zero/%rR/fR/fR, branch_mif_mregister_mnon_mzero___rrR__fR__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for branch-if-register-non-zero/%rR/fR/fR, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction branch-if-register-not-null/%rR/fR */
  JITTER_INSTRUCTION_PROLOG_(branch-if-register-not-null/%rR/fR, branch_mif_mregister_mnot_mnull___rrR__fR, cold)
  { /* This block begins with definitions for branch-if-register-not-null/%rR/fR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       28
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         branch-if-register-not-null/%rR/fR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "branch-if-register-not-null"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "branch-if-register-not-null/%rR/fR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME branch_mif_mregister_mnot_mnull___rrR__fR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity varies depending on whether we have fast labels. */
#ifdef JITTER_HAVE_PATCH_IN
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
#else
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 2
#endif // #ifdef JITTER_HAVE_PATCH_IN

  /* Define argument-access macros for branch-if-register-not-null/%rR/fR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a slow (therefore residual, passed as an offset)
        register. */
  /* Define a macro expanding to the slow register offset. */
#if defined(JITTER_DISPATCH_NO_THREADING)
# define JITTER_SLOW_REGISTER_OFFSET0 (JITTER_RESIDUAL_ARGUMENT_0.fixnum)
#elif defined (JITTER_DISPATCH_MINIMAL_THREADING)
# define JITTER_SLOW_REGISTER_OFFSET0 ((((union jitter_word*)jitter_ip)[0]).fixnum)
#else
# define JITTER_SLOW_REGISTER_OFFSET0 ((((union jitter_word*)jitter_ip)[1]).fixnum)
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
  /* Define a macro expanding to an l-value for the VM register content. */
#   define JITTER_ARG0  JITTER_SLOW_REGISTER_FROM_OFFSET(r, JITTER_SLOW_REGISTER_OFFSET0)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)

    /* The 1th argument is a "residual" fast label.  Define its
       _ARGF macro as the residual *index* (counting only fast labels, 0-based),
       so that at replication time we know what instruction address to patch in. */
#   define JITTER_ARGF1 0
    /* JITTER_ARG1 is intentionally not defined for a fast label. */

#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
    /* The 0th argument is a slow (therefore residual, passed as an offset)
        register. */
  /* Define a macro expanding to the slow register offset. */
#if defined(JITTER_DISPATCH_NO_THREADING)
# define JITTER_SLOW_REGISTER_OFFSET0 (JITTER_RESIDUAL_ARGUMENT_0.fixnum)
#elif defined (JITTER_DISPATCH_MINIMAL_THREADING)
# define JITTER_SLOW_REGISTER_OFFSET0 ((((union jitter_word*)jitter_ip)[0]).fixnum)
#else
# define JITTER_SLOW_REGISTER_OFFSET0 ((((union jitter_word*)jitter_ip)[1]).fixnum)
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
  /* Define a macro expanding to an l-value for the VM register content. */
#   define JITTER_ARG0  JITTER_SLOW_REGISTER_FROM_OFFSET(r, JITTER_SLOW_REGISTER_OFFSET0)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of branch-if-register-not-null/%rR/fR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "branch-if-register-not-null/%rR/fR"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for branch-if-register-not-null/%rR/fR . */
  {
/* User-specified code, user code block part: beginning. */

    JITTER_BRANCH_FAST_IF_NOTEQUAL(JITTER_ARG0,
                                   JITTERLISP_EMPTY_LIST,
                                   JITTER_ARGF1);
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for branch-if-register-not-null/%rR/fR . */

  //fprintf (stderr, "..Executed instruction %s\n", "branch-if-register-not-null/%rR/fR");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the branch-if-register-not-null/%rR/fR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(branch-if-register-not-null/%rR/fR, branch_mif_mregister_mnot_mnull___rrR__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for branch-if-register-not-null/%rR/fR, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction branch-if-register-null/%rR/fR */
  JITTER_INSTRUCTION_PROLOG_(branch-if-register-null/%rR/fR, branch_mif_mregister_mnull___rrR__fR, cold)
  { /* This block begins with definitions for branch-if-register-null/%rR/fR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       29
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         branch-if-register-null/%rR/fR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "branch-if-register-null"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "branch-if-register-null/%rR/fR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME branch_mif_mregister_mnull___rrR__fR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity varies depending on whether we have fast labels. */
#ifdef JITTER_HAVE_PATCH_IN
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
#else
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 2
#endif // #ifdef JITTER_HAVE_PATCH_IN

  /* Define argument-access macros for branch-if-register-null/%rR/fR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a slow (therefore residual, passed as an offset)
        register. */
  /* Define a macro expanding to the slow register offset. */
#if defined(JITTER_DISPATCH_NO_THREADING)
# define JITTER_SLOW_REGISTER_OFFSET0 (JITTER_RESIDUAL_ARGUMENT_0.fixnum)
#elif defined (JITTER_DISPATCH_MINIMAL_THREADING)
# define JITTER_SLOW_REGISTER_OFFSET0 ((((union jitter_word*)jitter_ip)[0]).fixnum)
#else
# define JITTER_SLOW_REGISTER_OFFSET0 ((((union jitter_word*)jitter_ip)[1]).fixnum)
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
  /* Define a macro expanding to an l-value for the VM register content. */
#   define JITTER_ARG0  JITTER_SLOW_REGISTER_FROM_OFFSET(r, JITTER_SLOW_REGISTER_OFFSET0)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)

    /* The 1th argument is a "residual" fast label.  Define its
       _ARGF macro as the residual *index* (counting only fast labels, 0-based),
       so that at replication time we know what instruction address to patch in. */
#   define JITTER_ARGF1 0
    /* JITTER_ARG1 is intentionally not defined for a fast label. */

#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
    /* The 0th argument is a slow (therefore residual, passed as an offset)
        register. */
  /* Define a macro expanding to the slow register offset. */
#if defined(JITTER_DISPATCH_NO_THREADING)
# define JITTER_SLOW_REGISTER_OFFSET0 (JITTER_RESIDUAL_ARGUMENT_0.fixnum)
#elif defined (JITTER_DISPATCH_MINIMAL_THREADING)
# define JITTER_SLOW_REGISTER_OFFSET0 ((((union jitter_word*)jitter_ip)[0]).fixnum)
#else
# define JITTER_SLOW_REGISTER_OFFSET0 ((((union jitter_word*)jitter_ip)[1]).fixnum)
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
  /* Define a macro expanding to an l-value for the VM register content. */
#   define JITTER_ARG0  JITTER_SLOW_REGISTER_FROM_OFFSET(r, JITTER_SLOW_REGISTER_OFFSET0)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of branch-if-register-null/%rR/fR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "branch-if-register-null/%rR/fR"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for branch-if-register-null/%rR/fR . */
  {
/* User-specified code, user code block part: beginning. */

    JITTER_BRANCH_FAST_IF_EQUAL(JITTER_ARG0,
                                JITTERLISP_EMPTY_LIST,
                                JITTER_ARGF1);
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for branch-if-register-null/%rR/fR . */

  //fprintf (stderr, "..Executed instruction %s\n", "branch-if-register-null/%rR/fR");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the branch-if-register-null/%rR/fR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(branch-if-register-null/%rR/fR, branch_mif_mregister_mnull___rrR__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for branch-if-register-null/%rR/fR, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction branch-if-register-positive/%rR/fR/fR */
  JITTER_INSTRUCTION_PROLOG_(branch-if-register-positive/%rR/fR/fR, branch_mif_mregister_mpositive___rrR__fR__fR, cold)
  { /* This block begins with definitions for branch-if-register-positive/%rR/fR/fR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       30
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         branch-if-register-positive/%rR/fR/fR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "branch-if-register-positive"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "branch-if-register-positive/%rR/fR/fR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME branch_mif_mregister_mpositive___rrR__fR__fR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity varies depending on whether we have fast labels. */
#ifdef JITTER_HAVE_PATCH_IN
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
#else
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 3
#endif // #ifdef JITTER_HAVE_PATCH_IN

  /* Define argument-access macros for branch-if-register-positive/%rR/fR/fR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a slow (therefore residual, passed as an offset)
        register. */
  /* Define a macro expanding to the slow register offset. */
#if defined(JITTER_DISPATCH_NO_THREADING)
# define JITTER_SLOW_REGISTER_OFFSET0 (JITTER_RESIDUAL_ARGUMENT_0.fixnum)
#elif defined (JITTER_DISPATCH_MINIMAL_THREADING)
# define JITTER_SLOW_REGISTER_OFFSET0 ((((union jitter_word*)jitter_ip)[0]).fixnum)
#else
# define JITTER_SLOW_REGISTER_OFFSET0 ((((union jitter_word*)jitter_ip)[1]).fixnum)
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
  /* Define a macro expanding to an l-value for the VM register content. */
#   define JITTER_ARG0  JITTER_SLOW_REGISTER_FROM_OFFSET(r, JITTER_SLOW_REGISTER_OFFSET0)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)

    /* The 1th argument is a "residual" fast label.  Define its
       _ARGF macro as the residual *index* (counting only fast labels, 0-based),
       so that at replication time we know what instruction address to patch in. */
#   define JITTER_ARGF1 0
    /* JITTER_ARG1 is intentionally not defined for a fast label. */

#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)

    /* The 2th argument is a "residual" fast label.  Define its
       _ARGF macro as the residual *index* (counting only fast labels, 0-based),
       so that at replication time we know what instruction address to patch in. */
#   define JITTER_ARGF2 1
    /* JITTER_ARG2 is intentionally not defined for a fast label. */

#   define JITTER_ARGN2 (JITTER_ARG2.fixnum)
#   define JITTER_ARGU2 (JITTER_ARG2.ufixnum)
#   define JITTER_ARGP2 (JITTER_ARG2.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
    /* The 0th argument is a slow (therefore residual, passed as an offset)
        register. */
  /* Define a macro expanding to the slow register offset. */
#if defined(JITTER_DISPATCH_NO_THREADING)
# define JITTER_SLOW_REGISTER_OFFSET0 (JITTER_RESIDUAL_ARGUMENT_0.fixnum)
#elif defined (JITTER_DISPATCH_MINIMAL_THREADING)
# define JITTER_SLOW_REGISTER_OFFSET0 ((((union jitter_word*)jitter_ip)[0]).fixnum)
#else
# define JITTER_SLOW_REGISTER_OFFSET0 ((((union jitter_word*)jitter_ip)[1]).fixnum)
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
  /* Define a macro expanding to an l-value for the VM register content. */
#   define JITTER_ARG0  JITTER_SLOW_REGISTER_FROM_OFFSET(r, JITTER_SLOW_REGISTER_OFFSET0)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG2  JITTER_RESIDUAL_ARGUMENT_2
    JITTER_MARK_RESIDUAL_2_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[2])
#else
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[3])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN2 (JITTER_ARG2.fixnum)
#   define JITTER_ARGU2 (JITTER_ARG2.ufixnum)
#   define JITTER_ARGP2 (JITTER_ARG2.pointer)
#   define JITTER_ARGF2 JITTER_ARGP2

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of branch-if-register-positive/%rR/fR/fR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "branch-if-register-positive/%rR/fR/fR"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for branch-if-register-positive/%rR/fR/fR . */
  {
/* User-specified code, user code block part: beginning. */

#if ! defined (JITTERLISP_UNSAFE)
    JITTERLISP_BRANCH_FAST_UNLESS_FIXNUM (JITTER_ARG0, JITTER_ARGF2);
#endif
    JITTER_BRANCH_FAST_IF_POSITIVE(JITTER_ARG0, JITTER_ARGF1);
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for branch-if-register-positive/%rR/fR/fR . */

  //fprintf (stderr, "..Executed instruction %s\n", "branch-if-register-positive/%rR/fR/fR");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the branch-if-register-positive/%rR/fR/fR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1
#   undef JITTER_SLOW_REGISTER_OFFSET2
#   undef JITTER_ARG2
#   undef JITTER_ARGN2
#   undef JITTER_ARGU2
#   undef JITTER_ARGP2
#   undef JITTER_ARGF2

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(branch-if-register-positive/%rR/fR/fR, branch_mif_mregister_mpositive___rrR__fR__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for branch-if-register-positive/%rR/fR/fR, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction branch-if-true/fR */
  JITTER_INSTRUCTION_PROLOG_(branch-if-true/fR, branch_mif_mtrue__fR, hot)
  { /* This block begins with definitions for branch-if-true/fR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       31
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         branch-if-true/fR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "branch-if-true"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "branch-if-true/fR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME branch_mif_mtrue__fR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity varies depending on whether we have fast labels. */
#ifdef JITTER_HAVE_PATCH_IN
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
#else
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
#endif // #ifdef JITTER_HAVE_PATCH_IN

  /* Define argument-access macros for branch-if-true/fR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a "residual" fast label.  Define its
       _ARGF macro as the residual *index* (counting only fast labels, 0-based),
       so that at replication time we know what instruction address to patch in. */
#   define JITTER_ARGF0 0
    /* JITTER_ARG0 is intentionally not defined for a fast label. */

#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of branch-if-true/fR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "branch-if-true/fR"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for branch-if-true/fR . */
  {
/* User-specified code, user code block part: beginning. */

    jitterlisp_object top = JITTER_TOP_MAINSTACK();
    JITTER_DROP_MAINSTACK();
    JITTER_BRANCH_FAST_IF_NOTEQUAL(top, JITTERLISP_FALSE, JITTER_ARGF0);
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for branch-if-true/fR . */

  //fprintf (stderr, "..Executed instruction %s\n", "branch-if-true/fR");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the branch-if-true/fR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(branch-if-true/fR, branch_mif_mtrue__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for branch-if-true/fR, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction call/n0/retR */
  JITTER_INSTRUCTION_PROLOG_(call/n0/retR, call__n0__retR, cold)
  { /* This block begins with definitions for call/n0/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       32
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         call/n0/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "call"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "call/n0/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME call__n0__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is a non-replacement and a caller.
       Its 1-th argument, a literal, is the return address where to jump
       back after the procedure returns.  Branch-and-link
       functionality is enabled for this instruction. */
/* This instruction is relocatable: use more efficient branches
   which can generate defects. */
#   undef JITTER_BRANCH_AND_LINK
#   define JITTER_BRANCH_AND_LINK      _JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   define JITTER_BRANCH_AND_LINK_WITH _JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK
#   define JITTER_BRANCH_FAST_AND_LINK _JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1

    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 0L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1


#if defined(JITTER_DISPATCH_NO_THREADING)             \
    && (! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)  \
        || /* is this a replacement? */ 0)
  /* We use the implicit argument at the end of the calling.
     instruction to discover the procedure return address. */
  const void * const _jitter_return_pointer
    __attribute__ ((unused)) = JITTER_ARGP1;
  /* And make it accessible to the user (who will usually call 
     JITTER_BRANCH_AND_LINK) thru a nice macro. */
# define _JITTER_RETURN_ADDRESS _jitter_return_pointer
#endif

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of call/n0/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "call/n0/retR"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for call/n0/retR . */
  {
/* User-specified code, user code block part: beginning. */

    const jitter_uint in_arity = JITTER_ARGN0;
    jitterlisp_object callee = JITTER_AT_DEPTH_MAINSTACK(in_arity);
    struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(callee);

    if (c->kind == jitterlisp_closure_type_compiled)
      {
        /* Make place for the return address in the return stack.  The
           actual value will be written by the callee. */
        JITTER_PUSH_UNSPECIFIED_RETURNSTACK();

        /* Branch-and-link to the native code, whose first instruction
           will be a prolog. */
        struct jitterlisp_compiled_closure *cc = & c->compiled;
        JITTER_BRANCH_AND_LINK(cc->first_program_point);
      }
    else
      {
        const struct jitterlisp_interpreted_closure *ic = & c->interpreted;

        /* Push an element on the main stack.  This way we can ensure that
           every actual is accessible thru memory in a contiguous array,
           even if the main stack is TOS-optimized.  Compute the address
           (on the main stack backing) where the actuals begin.

           Notice that the interpreted function we are calling is allowed
           to call into compiled code in its turn.  This is not a problem,
           as we are not moving stack pointers down until the call ends:
           the unused part of the main and return stacks is available to
           the callee. */
        JITTER_PUSH_UNSPECIFIED_MAINSTACK();
        jitterlisp_object *actuals
          // FIXME: add a stack operator to compute this address.
          = (& JITTER_UNDER_TOP_MAINSTACK()) - in_arity + 1;

        /* Call the interpreter. */
        jitterlisp_object interpretation_result
          = jitterlisp_call_interpreted (ic, actuals, in_arity);

        /* Remove as many elements as the in-arity plus one (the callee) from
           the stack, without affecting the top.  Unless JITTER_ARGN0 is
           residual this whole loops compiles to one instruction when the main
           stack is TOS-optimized, and doesn't touch memory. */
        int i;
        for (i = 0; i < in_arity + 1; i ++)
          JITTER_NIP_MAINSTACK();

        /* Now the stack is one element higher than it was before the call,
           containing the unspecified element at the top.  Replace it with
           the result.  Again this doesn't touch memory. */
        JITTER_TOP_MAINSTACK() = interpretation_result;
      }
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for call/n0/retR . */

  //fprintf (stderr, "..Executed instruction %s\n", "call/n0/retR");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the call/n0/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#if    defined(JITTER_DISPATCH_NO_THREADING)         \
    && ! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)
# undef _JITTER_RETURN_ADDRESS
#endif

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(call/n0/retR, call__n0__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for call/n0/retR, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction call/n1/retR */
  JITTER_INSTRUCTION_PROLOG_(call/n1/retR, call__n1__retR, cold)
  { /* This block begins with definitions for call/n1/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       33
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         call/n1/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "call"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "call/n1/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME call__n1__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is a non-replacement and a caller.
       Its 1-th argument, a literal, is the return address where to jump
       back after the procedure returns.  Branch-and-link
       functionality is enabled for this instruction. */
/* This instruction is relocatable: use more efficient branches
   which can generate defects. */
#   undef JITTER_BRANCH_AND_LINK
#   define JITTER_BRANCH_AND_LINK      _JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   define JITTER_BRANCH_AND_LINK_WITH _JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK
#   define JITTER_BRANCH_FAST_AND_LINK _JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1

    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 1L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1


#if defined(JITTER_DISPATCH_NO_THREADING)             \
    && (! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)  \
        || /* is this a replacement? */ 0)
  /* We use the implicit argument at the end of the calling.
     instruction to discover the procedure return address. */
  const void * const _jitter_return_pointer
    __attribute__ ((unused)) = JITTER_ARGP1;
  /* And make it accessible to the user (who will usually call 
     JITTER_BRANCH_AND_LINK) thru a nice macro. */
# define _JITTER_RETURN_ADDRESS _jitter_return_pointer
#endif

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of call/n1/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "call/n1/retR"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for call/n1/retR . */
  {
/* User-specified code, user code block part: beginning. */

    const jitter_uint in_arity = JITTER_ARGN0;
    jitterlisp_object callee = JITTER_AT_DEPTH_MAINSTACK(in_arity);
    struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(callee);

    if (c->kind == jitterlisp_closure_type_compiled)
      {
        /* Make place for the return address in the return stack.  The
           actual value will be written by the callee. */
        JITTER_PUSH_UNSPECIFIED_RETURNSTACK();

        /* Branch-and-link to the native code, whose first instruction
           will be a prolog. */
        struct jitterlisp_compiled_closure *cc = & c->compiled;
        JITTER_BRANCH_AND_LINK(cc->first_program_point);
      }
    else
      {
        const struct jitterlisp_interpreted_closure *ic = & c->interpreted;

        /* Push an element on the main stack.  This way we can ensure that
           every actual is accessible thru memory in a contiguous array,
           even if the main stack is TOS-optimized.  Compute the address
           (on the main stack backing) where the actuals begin.

           Notice that the interpreted function we are calling is allowed
           to call into compiled code in its turn.  This is not a problem,
           as we are not moving stack pointers down until the call ends:
           the unused part of the main and return stacks is available to
           the callee. */
        JITTER_PUSH_UNSPECIFIED_MAINSTACK();
        jitterlisp_object *actuals
          // FIXME: add a stack operator to compute this address.
          = (& JITTER_UNDER_TOP_MAINSTACK()) - in_arity + 1;

        /* Call the interpreter. */
        jitterlisp_object interpretation_result
          = jitterlisp_call_interpreted (ic, actuals, in_arity);

        /* Remove as many elements as the in-arity plus one (the callee) from
           the stack, without affecting the top.  Unless JITTER_ARGN0 is
           residual this whole loops compiles to one instruction when the main
           stack is TOS-optimized, and doesn't touch memory. */
        int i;
        for (i = 0; i < in_arity + 1; i ++)
          JITTER_NIP_MAINSTACK();

        /* Now the stack is one element higher than it was before the call,
           containing the unspecified element at the top.  Replace it with
           the result.  Again this doesn't touch memory. */
        JITTER_TOP_MAINSTACK() = interpretation_result;
      }
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for call/n1/retR . */

  //fprintf (stderr, "..Executed instruction %s\n", "call/n1/retR");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the call/n1/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#if    defined(JITTER_DISPATCH_NO_THREADING)         \
    && ! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)
# undef _JITTER_RETURN_ADDRESS
#endif

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(call/n1/retR, call__n1__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for call/n1/retR, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction call/n2/retR */
  JITTER_INSTRUCTION_PROLOG_(call/n2/retR, call__n2__retR, cold)
  { /* This block begins with definitions for call/n2/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       34
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         call/n2/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "call"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "call/n2/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME call__n2__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is a non-replacement and a caller.
       Its 1-th argument, a literal, is the return address where to jump
       back after the procedure returns.  Branch-and-link
       functionality is enabled for this instruction. */
/* This instruction is relocatable: use more efficient branches
   which can generate defects. */
#   undef JITTER_BRANCH_AND_LINK
#   define JITTER_BRANCH_AND_LINK      _JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   define JITTER_BRANCH_AND_LINK_WITH _JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK
#   define JITTER_BRANCH_FAST_AND_LINK _JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1

    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 2L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1


#if defined(JITTER_DISPATCH_NO_THREADING)             \
    && (! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)  \
        || /* is this a replacement? */ 0)
  /* We use the implicit argument at the end of the calling.
     instruction to discover the procedure return address. */
  const void * const _jitter_return_pointer
    __attribute__ ((unused)) = JITTER_ARGP1;
  /* And make it accessible to the user (who will usually call 
     JITTER_BRANCH_AND_LINK) thru a nice macro. */
# define _JITTER_RETURN_ADDRESS _jitter_return_pointer
#endif

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of call/n2/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "call/n2/retR"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for call/n2/retR . */
  {
/* User-specified code, user code block part: beginning. */

    const jitter_uint in_arity = JITTER_ARGN0;
    jitterlisp_object callee = JITTER_AT_DEPTH_MAINSTACK(in_arity);
    struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(callee);

    if (c->kind == jitterlisp_closure_type_compiled)
      {
        /* Make place for the return address in the return stack.  The
           actual value will be written by the callee. */
        JITTER_PUSH_UNSPECIFIED_RETURNSTACK();

        /* Branch-and-link to the native code, whose first instruction
           will be a prolog. */
        struct jitterlisp_compiled_closure *cc = & c->compiled;
        JITTER_BRANCH_AND_LINK(cc->first_program_point);
      }
    else
      {
        const struct jitterlisp_interpreted_closure *ic = & c->interpreted;

        /* Push an element on the main stack.  This way we can ensure that
           every actual is accessible thru memory in a contiguous array,
           even if the main stack is TOS-optimized.  Compute the address
           (on the main stack backing) where the actuals begin.

           Notice that the interpreted function we are calling is allowed
           to call into compiled code in its turn.  This is not a problem,
           as we are not moving stack pointers down until the call ends:
           the unused part of the main and return stacks is available to
           the callee. */
        JITTER_PUSH_UNSPECIFIED_MAINSTACK();
        jitterlisp_object *actuals
          // FIXME: add a stack operator to compute this address.
          = (& JITTER_UNDER_TOP_MAINSTACK()) - in_arity + 1;

        /* Call the interpreter. */
        jitterlisp_object interpretation_result
          = jitterlisp_call_interpreted (ic, actuals, in_arity);

        /* Remove as many elements as the in-arity plus one (the callee) from
           the stack, without affecting the top.  Unless JITTER_ARGN0 is
           residual this whole loops compiles to one instruction when the main
           stack is TOS-optimized, and doesn't touch memory. */
        int i;
        for (i = 0; i < in_arity + 1; i ++)
          JITTER_NIP_MAINSTACK();

        /* Now the stack is one element higher than it was before the call,
           containing the unspecified element at the top.  Replace it with
           the result.  Again this doesn't touch memory. */
        JITTER_TOP_MAINSTACK() = interpretation_result;
      }
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for call/n2/retR . */

  //fprintf (stderr, "..Executed instruction %s\n", "call/n2/retR");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the call/n2/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#if    defined(JITTER_DISPATCH_NO_THREADING)         \
    && ! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)
# undef _JITTER_RETURN_ADDRESS
#endif

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(call/n2/retR, call__n2__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for call/n2/retR, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction call/n3/retR */
  JITTER_INSTRUCTION_PROLOG_(call/n3/retR, call__n3__retR, cold)
  { /* This block begins with definitions for call/n3/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       35
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         call/n3/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "call"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "call/n3/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME call__n3__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is a non-replacement and a caller.
       Its 1-th argument, a literal, is the return address where to jump
       back after the procedure returns.  Branch-and-link
       functionality is enabled for this instruction. */
/* This instruction is relocatable: use more efficient branches
   which can generate defects. */
#   undef JITTER_BRANCH_AND_LINK
#   define JITTER_BRANCH_AND_LINK      _JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   define JITTER_BRANCH_AND_LINK_WITH _JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK
#   define JITTER_BRANCH_FAST_AND_LINK _JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1

    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 3L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1


#if defined(JITTER_DISPATCH_NO_THREADING)             \
    && (! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)  \
        || /* is this a replacement? */ 0)
  /* We use the implicit argument at the end of the calling.
     instruction to discover the procedure return address. */
  const void * const _jitter_return_pointer
    __attribute__ ((unused)) = JITTER_ARGP1;
  /* And make it accessible to the user (who will usually call 
     JITTER_BRANCH_AND_LINK) thru a nice macro. */
# define _JITTER_RETURN_ADDRESS _jitter_return_pointer
#endif

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of call/n3/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "call/n3/retR"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for call/n3/retR . */
  {
/* User-specified code, user code block part: beginning. */

    const jitter_uint in_arity = JITTER_ARGN0;
    jitterlisp_object callee = JITTER_AT_DEPTH_MAINSTACK(in_arity);
    struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(callee);

    if (c->kind == jitterlisp_closure_type_compiled)
      {
        /* Make place for the return address in the return stack.  The
           actual value will be written by the callee. */
        JITTER_PUSH_UNSPECIFIED_RETURNSTACK();

        /* Branch-and-link to the native code, whose first instruction
           will be a prolog. */
        struct jitterlisp_compiled_closure *cc = & c->compiled;
        JITTER_BRANCH_AND_LINK(cc->first_program_point);
      }
    else
      {
        const struct jitterlisp_interpreted_closure *ic = & c->interpreted;

        /* Push an element on the main stack.  This way we can ensure that
           every actual is accessible thru memory in a contiguous array,
           even if the main stack is TOS-optimized.  Compute the address
           (on the main stack backing) where the actuals begin.

           Notice that the interpreted function we are calling is allowed
           to call into compiled code in its turn.  This is not a problem,
           as we are not moving stack pointers down until the call ends:
           the unused part of the main and return stacks is available to
           the callee. */
        JITTER_PUSH_UNSPECIFIED_MAINSTACK();
        jitterlisp_object *actuals
          // FIXME: add a stack operator to compute this address.
          = (& JITTER_UNDER_TOP_MAINSTACK()) - in_arity + 1;

        /* Call the interpreter. */
        jitterlisp_object interpretation_result
          = jitterlisp_call_interpreted (ic, actuals, in_arity);

        /* Remove as many elements as the in-arity plus one (the callee) from
           the stack, without affecting the top.  Unless JITTER_ARGN0 is
           residual this whole loops compiles to one instruction when the main
           stack is TOS-optimized, and doesn't touch memory. */
        int i;
        for (i = 0; i < in_arity + 1; i ++)
          JITTER_NIP_MAINSTACK();

        /* Now the stack is one element higher than it was before the call,
           containing the unspecified element at the top.  Replace it with
           the result.  Again this doesn't touch memory. */
        JITTER_TOP_MAINSTACK() = interpretation_result;
      }
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for call/n3/retR . */

  //fprintf (stderr, "..Executed instruction %s\n", "call/n3/retR");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the call/n3/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#if    defined(JITTER_DISPATCH_NO_THREADING)         \
    && ! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)
# undef _JITTER_RETURN_ADDRESS
#endif

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(call/n3/retR, call__n3__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for call/n3/retR, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction call/n4/retR */
  JITTER_INSTRUCTION_PROLOG_(call/n4/retR, call__n4__retR, cold)
  { /* This block begins with definitions for call/n4/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       36
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         call/n4/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "call"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "call/n4/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME call__n4__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is a non-replacement and a caller.
       Its 1-th argument, a literal, is the return address where to jump
       back after the procedure returns.  Branch-and-link
       functionality is enabled for this instruction. */
/* This instruction is relocatable: use more efficient branches
   which can generate defects. */
#   undef JITTER_BRANCH_AND_LINK
#   define JITTER_BRANCH_AND_LINK      _JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   define JITTER_BRANCH_AND_LINK_WITH _JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK
#   define JITTER_BRANCH_FAST_AND_LINK _JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1

    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 4L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1


#if defined(JITTER_DISPATCH_NO_THREADING)             \
    && (! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)  \
        || /* is this a replacement? */ 0)
  /* We use the implicit argument at the end of the calling.
     instruction to discover the procedure return address. */
  const void * const _jitter_return_pointer
    __attribute__ ((unused)) = JITTER_ARGP1;
  /* And make it accessible to the user (who will usually call 
     JITTER_BRANCH_AND_LINK) thru a nice macro. */
# define _JITTER_RETURN_ADDRESS _jitter_return_pointer
#endif

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of call/n4/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "call/n4/retR"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for call/n4/retR . */
  {
/* User-specified code, user code block part: beginning. */

    const jitter_uint in_arity = JITTER_ARGN0;
    jitterlisp_object callee = JITTER_AT_DEPTH_MAINSTACK(in_arity);
    struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(callee);

    if (c->kind == jitterlisp_closure_type_compiled)
      {
        /* Make place for the return address in the return stack.  The
           actual value will be written by the callee. */
        JITTER_PUSH_UNSPECIFIED_RETURNSTACK();

        /* Branch-and-link to the native code, whose first instruction
           will be a prolog. */
        struct jitterlisp_compiled_closure *cc = & c->compiled;
        JITTER_BRANCH_AND_LINK(cc->first_program_point);
      }
    else
      {
        const struct jitterlisp_interpreted_closure *ic = & c->interpreted;

        /* Push an element on the main stack.  This way we can ensure that
           every actual is accessible thru memory in a contiguous array,
           even if the main stack is TOS-optimized.  Compute the address
           (on the main stack backing) where the actuals begin.

           Notice that the interpreted function we are calling is allowed
           to call into compiled code in its turn.  This is not a problem,
           as we are not moving stack pointers down until the call ends:
           the unused part of the main and return stacks is available to
           the callee. */
        JITTER_PUSH_UNSPECIFIED_MAINSTACK();
        jitterlisp_object *actuals
          // FIXME: add a stack operator to compute this address.
          = (& JITTER_UNDER_TOP_MAINSTACK()) - in_arity + 1;

        /* Call the interpreter. */
        jitterlisp_object interpretation_result
          = jitterlisp_call_interpreted (ic, actuals, in_arity);

        /* Remove as many elements as the in-arity plus one (the callee) from
           the stack, without affecting the top.  Unless JITTER_ARGN0 is
           residual this whole loops compiles to one instruction when the main
           stack is TOS-optimized, and doesn't touch memory. */
        int i;
        for (i = 0; i < in_arity + 1; i ++)
          JITTER_NIP_MAINSTACK();

        /* Now the stack is one element higher than it was before the call,
           containing the unspecified element at the top.  Replace it with
           the result.  Again this doesn't touch memory. */
        JITTER_TOP_MAINSTACK() = interpretation_result;
      }
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for call/n4/retR . */

  //fprintf (stderr, "..Executed instruction %s\n", "call/n4/retR");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the call/n4/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#if    defined(JITTER_DISPATCH_NO_THREADING)         \
    && ! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)
# undef _JITTER_RETURN_ADDRESS
#endif

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(call/n4/retR, call__n4__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for call/n4/retR, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction call/n5/retR */
  JITTER_INSTRUCTION_PROLOG_(call/n5/retR, call__n5__retR, cold)
  { /* This block begins with definitions for call/n5/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       37
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         call/n5/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "call"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "call/n5/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME call__n5__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is a non-replacement and a caller.
       Its 1-th argument, a literal, is the return address where to jump
       back after the procedure returns.  Branch-and-link
       functionality is enabled for this instruction. */
/* This instruction is relocatable: use more efficient branches
   which can generate defects. */
#   undef JITTER_BRANCH_AND_LINK
#   define JITTER_BRANCH_AND_LINK      _JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   define JITTER_BRANCH_AND_LINK_WITH _JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK
#   define JITTER_BRANCH_FAST_AND_LINK _JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1

    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 5L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1


#if defined(JITTER_DISPATCH_NO_THREADING)             \
    && (! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)  \
        || /* is this a replacement? */ 0)
  /* We use the implicit argument at the end of the calling.
     instruction to discover the procedure return address. */
  const void * const _jitter_return_pointer
    __attribute__ ((unused)) = JITTER_ARGP1;
  /* And make it accessible to the user (who will usually call 
     JITTER_BRANCH_AND_LINK) thru a nice macro. */
# define _JITTER_RETURN_ADDRESS _jitter_return_pointer
#endif

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of call/n5/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "call/n5/retR"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for call/n5/retR . */
  {
/* User-specified code, user code block part: beginning. */

    const jitter_uint in_arity = JITTER_ARGN0;
    jitterlisp_object callee = JITTER_AT_DEPTH_MAINSTACK(in_arity);
    struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(callee);

    if (c->kind == jitterlisp_closure_type_compiled)
      {
        /* Make place for the return address in the return stack.  The
           actual value will be written by the callee. */
        JITTER_PUSH_UNSPECIFIED_RETURNSTACK();

        /* Branch-and-link to the native code, whose first instruction
           will be a prolog. */
        struct jitterlisp_compiled_closure *cc = & c->compiled;
        JITTER_BRANCH_AND_LINK(cc->first_program_point);
      }
    else
      {
        const struct jitterlisp_interpreted_closure *ic = & c->interpreted;

        /* Push an element on the main stack.  This way we can ensure that
           every actual is accessible thru memory in a contiguous array,
           even if the main stack is TOS-optimized.  Compute the address
           (on the main stack backing) where the actuals begin.

           Notice that the interpreted function we are calling is allowed
           to call into compiled code in its turn.  This is not a problem,
           as we are not moving stack pointers down until the call ends:
           the unused part of the main and return stacks is available to
           the callee. */
        JITTER_PUSH_UNSPECIFIED_MAINSTACK();
        jitterlisp_object *actuals
          // FIXME: add a stack operator to compute this address.
          = (& JITTER_UNDER_TOP_MAINSTACK()) - in_arity + 1;

        /* Call the interpreter. */
        jitterlisp_object interpretation_result
          = jitterlisp_call_interpreted (ic, actuals, in_arity);

        /* Remove as many elements as the in-arity plus one (the callee) from
           the stack, without affecting the top.  Unless JITTER_ARGN0 is
           residual this whole loops compiles to one instruction when the main
           stack is TOS-optimized, and doesn't touch memory. */
        int i;
        for (i = 0; i < in_arity + 1; i ++)
          JITTER_NIP_MAINSTACK();

        /* Now the stack is one element higher than it was before the call,
           containing the unspecified element at the top.  Replace it with
           the result.  Again this doesn't touch memory. */
        JITTER_TOP_MAINSTACK() = interpretation_result;
      }
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for call/n5/retR . */

  //fprintf (stderr, "..Executed instruction %s\n", "call/n5/retR");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the call/n5/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#if    defined(JITTER_DISPATCH_NO_THREADING)         \
    && ! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)
# undef _JITTER_RETURN_ADDRESS
#endif

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(call/n5/retR, call__n5__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for call/n5/retR, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction call/n6/retR */
  JITTER_INSTRUCTION_PROLOG_(call/n6/retR, call__n6__retR, cold)
  { /* This block begins with definitions for call/n6/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       38
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         call/n6/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "call"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "call/n6/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME call__n6__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is a non-replacement and a caller.
       Its 1-th argument, a literal, is the return address where to jump
       back after the procedure returns.  Branch-and-link
       functionality is enabled for this instruction. */
/* This instruction is relocatable: use more efficient branches
   which can generate defects. */
#   undef JITTER_BRANCH_AND_LINK
#   define JITTER_BRANCH_AND_LINK      _JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   define JITTER_BRANCH_AND_LINK_WITH _JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK
#   define JITTER_BRANCH_FAST_AND_LINK _JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1

    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 6L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1


#if defined(JITTER_DISPATCH_NO_THREADING)             \
    && (! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)  \
        || /* is this a replacement? */ 0)
  /* We use the implicit argument at the end of the calling.
     instruction to discover the procedure return address. */
  const void * const _jitter_return_pointer
    __attribute__ ((unused)) = JITTER_ARGP1;
  /* And make it accessible to the user (who will usually call 
     JITTER_BRANCH_AND_LINK) thru a nice macro. */
# define _JITTER_RETURN_ADDRESS _jitter_return_pointer
#endif

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of call/n6/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "call/n6/retR"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for call/n6/retR . */
  {
/* User-specified code, user code block part: beginning. */

    const jitter_uint in_arity = JITTER_ARGN0;
    jitterlisp_object callee = JITTER_AT_DEPTH_MAINSTACK(in_arity);
    struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(callee);

    if (c->kind == jitterlisp_closure_type_compiled)
      {
        /* Make place for the return address in the return stack.  The
           actual value will be written by the callee. */
        JITTER_PUSH_UNSPECIFIED_RETURNSTACK();

        /* Branch-and-link to the native code, whose first instruction
           will be a prolog. */
        struct jitterlisp_compiled_closure *cc = & c->compiled;
        JITTER_BRANCH_AND_LINK(cc->first_program_point);
      }
    else
      {
        const struct jitterlisp_interpreted_closure *ic = & c->interpreted;

        /* Push an element on the main stack.  This way we can ensure that
           every actual is accessible thru memory in a contiguous array,
           even if the main stack is TOS-optimized.  Compute the address
           (on the main stack backing) where the actuals begin.

           Notice that the interpreted function we are calling is allowed
           to call into compiled code in its turn.  This is not a problem,
           as we are not moving stack pointers down until the call ends:
           the unused part of the main and return stacks is available to
           the callee. */
        JITTER_PUSH_UNSPECIFIED_MAINSTACK();
        jitterlisp_object *actuals
          // FIXME: add a stack operator to compute this address.
          = (& JITTER_UNDER_TOP_MAINSTACK()) - in_arity + 1;

        /* Call the interpreter. */
        jitterlisp_object interpretation_result
          = jitterlisp_call_interpreted (ic, actuals, in_arity);

        /* Remove as many elements as the in-arity plus one (the callee) from
           the stack, without affecting the top.  Unless JITTER_ARGN0 is
           residual this whole loops compiles to one instruction when the main
           stack is TOS-optimized, and doesn't touch memory. */
        int i;
        for (i = 0; i < in_arity + 1; i ++)
          JITTER_NIP_MAINSTACK();

        /* Now the stack is one element higher than it was before the call,
           containing the unspecified element at the top.  Replace it with
           the result.  Again this doesn't touch memory. */
        JITTER_TOP_MAINSTACK() = interpretation_result;
      }
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for call/n6/retR . */

  //fprintf (stderr, "..Executed instruction %s\n", "call/n6/retR");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the call/n6/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#if    defined(JITTER_DISPATCH_NO_THREADING)         \
    && ! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)
# undef _JITTER_RETURN_ADDRESS
#endif

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(call/n6/retR, call__n6__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for call/n6/retR, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction call/n7/retR */
  JITTER_INSTRUCTION_PROLOG_(call/n7/retR, call__n7__retR, cold)
  { /* This block begins with definitions for call/n7/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       39
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         call/n7/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "call"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "call/n7/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME call__n7__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is a non-replacement and a caller.
       Its 1-th argument, a literal, is the return address where to jump
       back after the procedure returns.  Branch-and-link
       functionality is enabled for this instruction. */
/* This instruction is relocatable: use more efficient branches
   which can generate defects. */
#   undef JITTER_BRANCH_AND_LINK
#   define JITTER_BRANCH_AND_LINK      _JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   define JITTER_BRANCH_AND_LINK_WITH _JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK
#   define JITTER_BRANCH_FAST_AND_LINK _JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1

    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 7L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1


#if defined(JITTER_DISPATCH_NO_THREADING)             \
    && (! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)  \
        || /* is this a replacement? */ 0)
  /* We use the implicit argument at the end of the calling.
     instruction to discover the procedure return address. */
  const void * const _jitter_return_pointer
    __attribute__ ((unused)) = JITTER_ARGP1;
  /* And make it accessible to the user (who will usually call 
     JITTER_BRANCH_AND_LINK) thru a nice macro. */
# define _JITTER_RETURN_ADDRESS _jitter_return_pointer
#endif

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of call/n7/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "call/n7/retR"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for call/n7/retR . */
  {
/* User-specified code, user code block part: beginning. */

    const jitter_uint in_arity = JITTER_ARGN0;
    jitterlisp_object callee = JITTER_AT_DEPTH_MAINSTACK(in_arity);
    struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(callee);

    if (c->kind == jitterlisp_closure_type_compiled)
      {
        /* Make place for the return address in the return stack.  The
           actual value will be written by the callee. */
        JITTER_PUSH_UNSPECIFIED_RETURNSTACK();

        /* Branch-and-link to the native code, whose first instruction
           will be a prolog. */
        struct jitterlisp_compiled_closure *cc = & c->compiled;
        JITTER_BRANCH_AND_LINK(cc->first_program_point);
      }
    else
      {
        const struct jitterlisp_interpreted_closure *ic = & c->interpreted;

        /* Push an element on the main stack.  This way we can ensure that
           every actual is accessible thru memory in a contiguous array,
           even if the main stack is TOS-optimized.  Compute the address
           (on the main stack backing) where the actuals begin.

           Notice that the interpreted function we are calling is allowed
           to call into compiled code in its turn.  This is not a problem,
           as we are not moving stack pointers down until the call ends:
           the unused part of the main and return stacks is available to
           the callee. */
        JITTER_PUSH_UNSPECIFIED_MAINSTACK();
        jitterlisp_object *actuals
          // FIXME: add a stack operator to compute this address.
          = (& JITTER_UNDER_TOP_MAINSTACK()) - in_arity + 1;

        /* Call the interpreter. */
        jitterlisp_object interpretation_result
          = jitterlisp_call_interpreted (ic, actuals, in_arity);

        /* Remove as many elements as the in-arity plus one (the callee) from
           the stack, without affecting the top.  Unless JITTER_ARGN0 is
           residual this whole loops compiles to one instruction when the main
           stack is TOS-optimized, and doesn't touch memory. */
        int i;
        for (i = 0; i < in_arity + 1; i ++)
          JITTER_NIP_MAINSTACK();

        /* Now the stack is one element higher than it was before the call,
           containing the unspecified element at the top.  Replace it with
           the result.  Again this doesn't touch memory. */
        JITTER_TOP_MAINSTACK() = interpretation_result;
      }
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for call/n7/retR . */

  //fprintf (stderr, "..Executed instruction %s\n", "call/n7/retR");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the call/n7/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#if    defined(JITTER_DISPATCH_NO_THREADING)         \
    && ! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)
# undef _JITTER_RETURN_ADDRESS
#endif

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(call/n7/retR, call__n7__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for call/n7/retR, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction call/n8/retR */
  JITTER_INSTRUCTION_PROLOG_(call/n8/retR, call__n8__retR, cold)
  { /* This block begins with definitions for call/n8/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       40
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         call/n8/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "call"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "call/n8/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME call__n8__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is a non-replacement and a caller.
       Its 1-th argument, a literal, is the return address where to jump
       back after the procedure returns.  Branch-and-link
       functionality is enabled for this instruction. */
/* This instruction is relocatable: use more efficient branches
   which can generate defects. */
#   undef JITTER_BRANCH_AND_LINK
#   define JITTER_BRANCH_AND_LINK      _JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   define JITTER_BRANCH_AND_LINK_WITH _JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK
#   define JITTER_BRANCH_FAST_AND_LINK _JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1

    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 8L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1


#if defined(JITTER_DISPATCH_NO_THREADING)             \
    && (! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)  \
        || /* is this a replacement? */ 0)
  /* We use the implicit argument at the end of the calling.
     instruction to discover the procedure return address. */
  const void * const _jitter_return_pointer
    __attribute__ ((unused)) = JITTER_ARGP1;
  /* And make it accessible to the user (who will usually call 
     JITTER_BRANCH_AND_LINK) thru a nice macro. */
# define _JITTER_RETURN_ADDRESS _jitter_return_pointer
#endif

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of call/n8/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "call/n8/retR"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for call/n8/retR . */
  {
/* User-specified code, user code block part: beginning. */

    const jitter_uint in_arity = JITTER_ARGN0;
    jitterlisp_object callee = JITTER_AT_DEPTH_MAINSTACK(in_arity);
    struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(callee);

    if (c->kind == jitterlisp_closure_type_compiled)
      {
        /* Make place for the return address in the return stack.  The
           actual value will be written by the callee. */
        JITTER_PUSH_UNSPECIFIED_RETURNSTACK();

        /* Branch-and-link to the native code, whose first instruction
           will be a prolog. */
        struct jitterlisp_compiled_closure *cc = & c->compiled;
        JITTER_BRANCH_AND_LINK(cc->first_program_point);
      }
    else
      {
        const struct jitterlisp_interpreted_closure *ic = & c->interpreted;

        /* Push an element on the main stack.  This way we can ensure that
           every actual is accessible thru memory in a contiguous array,
           even if the main stack is TOS-optimized.  Compute the address
           (on the main stack backing) where the actuals begin.

           Notice that the interpreted function we are calling is allowed
           to call into compiled code in its turn.  This is not a problem,
           as we are not moving stack pointers down until the call ends:
           the unused part of the main and return stacks is available to
           the callee. */
        JITTER_PUSH_UNSPECIFIED_MAINSTACK();
        jitterlisp_object *actuals
          // FIXME: add a stack operator to compute this address.
          = (& JITTER_UNDER_TOP_MAINSTACK()) - in_arity + 1;

        /* Call the interpreter. */
        jitterlisp_object interpretation_result
          = jitterlisp_call_interpreted (ic, actuals, in_arity);

        /* Remove as many elements as the in-arity plus one (the callee) from
           the stack, without affecting the top.  Unless JITTER_ARGN0 is
           residual this whole loops compiles to one instruction when the main
           stack is TOS-optimized, and doesn't touch memory. */
        int i;
        for (i = 0; i < in_arity + 1; i ++)
          JITTER_NIP_MAINSTACK();

        /* Now the stack is one element higher than it was before the call,
           containing the unspecified element at the top.  Replace it with
           the result.  Again this doesn't touch memory. */
        JITTER_TOP_MAINSTACK() = interpretation_result;
      }
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for call/n8/retR . */

  //fprintf (stderr, "..Executed instruction %s\n", "call/n8/retR");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the call/n8/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#if    defined(JITTER_DISPATCH_NO_THREADING)         \
    && ! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)
# undef _JITTER_RETURN_ADDRESS
#endif

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(call/n8/retR, call__n8__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for call/n8/retR, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction call/n9/retR */
  JITTER_INSTRUCTION_PROLOG_(call/n9/retR, call__n9__retR, cold)
  { /* This block begins with definitions for call/n9/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       41
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         call/n9/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "call"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "call/n9/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME call__n9__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is a non-replacement and a caller.
       Its 1-th argument, a literal, is the return address where to jump
       back after the procedure returns.  Branch-and-link
       functionality is enabled for this instruction. */
/* This instruction is relocatable: use more efficient branches
   which can generate defects. */
#   undef JITTER_BRANCH_AND_LINK
#   define JITTER_BRANCH_AND_LINK      _JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   define JITTER_BRANCH_AND_LINK_WITH _JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK
#   define JITTER_BRANCH_FAST_AND_LINK _JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1

    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 9L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1


#if defined(JITTER_DISPATCH_NO_THREADING)             \
    && (! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)  \
        || /* is this a replacement? */ 0)
  /* We use the implicit argument at the end of the calling.
     instruction to discover the procedure return address. */
  const void * const _jitter_return_pointer
    __attribute__ ((unused)) = JITTER_ARGP1;
  /* And make it accessible to the user (who will usually call 
     JITTER_BRANCH_AND_LINK) thru a nice macro. */
# define _JITTER_RETURN_ADDRESS _jitter_return_pointer
#endif

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of call/n9/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "call/n9/retR"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for call/n9/retR . */
  {
/* User-specified code, user code block part: beginning. */

    const jitter_uint in_arity = JITTER_ARGN0;
    jitterlisp_object callee = JITTER_AT_DEPTH_MAINSTACK(in_arity);
    struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(callee);

    if (c->kind == jitterlisp_closure_type_compiled)
      {
        /* Make place for the return address in the return stack.  The
           actual value will be written by the callee. */
        JITTER_PUSH_UNSPECIFIED_RETURNSTACK();

        /* Branch-and-link to the native code, whose first instruction
           will be a prolog. */
        struct jitterlisp_compiled_closure *cc = & c->compiled;
        JITTER_BRANCH_AND_LINK(cc->first_program_point);
      }
    else
      {
        const struct jitterlisp_interpreted_closure *ic = & c->interpreted;

        /* Push an element on the main stack.  This way we can ensure that
           every actual is accessible thru memory in a contiguous array,
           even if the main stack is TOS-optimized.  Compute the address
           (on the main stack backing) where the actuals begin.

           Notice that the interpreted function we are calling is allowed
           to call into compiled code in its turn.  This is not a problem,
           as we are not moving stack pointers down until the call ends:
           the unused part of the main and return stacks is available to
           the callee. */
        JITTER_PUSH_UNSPECIFIED_MAINSTACK();
        jitterlisp_object *actuals
          // FIXME: add a stack operator to compute this address.
          = (& JITTER_UNDER_TOP_MAINSTACK()) - in_arity + 1;

        /* Call the interpreter. */
        jitterlisp_object interpretation_result
          = jitterlisp_call_interpreted (ic, actuals, in_arity);

        /* Remove as many elements as the in-arity plus one (the callee) from
           the stack, without affecting the top.  Unless JITTER_ARGN0 is
           residual this whole loops compiles to one instruction when the main
           stack is TOS-optimized, and doesn't touch memory. */
        int i;
        for (i = 0; i < in_arity + 1; i ++)
          JITTER_NIP_MAINSTACK();

        /* Now the stack is one element higher than it was before the call,
           containing the unspecified element at the top.  Replace it with
           the result.  Again this doesn't touch memory. */
        JITTER_TOP_MAINSTACK() = interpretation_result;
      }
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for call/n9/retR . */

  //fprintf (stderr, "..Executed instruction %s\n", "call/n9/retR");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the call/n9/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#if    defined(JITTER_DISPATCH_NO_THREADING)         \
    && ! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)
# undef _JITTER_RETURN_ADDRESS
#endif

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(call/n9/retR, call__n9__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for call/n9/retR, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction call/n10/retR */
  JITTER_INSTRUCTION_PROLOG_(call/n10/retR, call__n10__retR, cold)
  { /* This block begins with definitions for call/n10/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       42
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         call/n10/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "call"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "call/n10/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME call__n10__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is a non-replacement and a caller.
       Its 1-th argument, a literal, is the return address where to jump
       back after the procedure returns.  Branch-and-link
       functionality is enabled for this instruction. */
/* This instruction is relocatable: use more efficient branches
   which can generate defects. */
#   undef JITTER_BRANCH_AND_LINK
#   define JITTER_BRANCH_AND_LINK      _JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   define JITTER_BRANCH_AND_LINK_WITH _JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK
#   define JITTER_BRANCH_FAST_AND_LINK _JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1

    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 10L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1


#if defined(JITTER_DISPATCH_NO_THREADING)             \
    && (! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)  \
        || /* is this a replacement? */ 0)
  /* We use the implicit argument at the end of the calling.
     instruction to discover the procedure return address. */
  const void * const _jitter_return_pointer
    __attribute__ ((unused)) = JITTER_ARGP1;
  /* And make it accessible to the user (who will usually call 
     JITTER_BRANCH_AND_LINK) thru a nice macro. */
# define _JITTER_RETURN_ADDRESS _jitter_return_pointer
#endif

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of call/n10/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "call/n10/retR"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for call/n10/retR . */
  {
/* User-specified code, user code block part: beginning. */

    const jitter_uint in_arity = JITTER_ARGN0;
    jitterlisp_object callee = JITTER_AT_DEPTH_MAINSTACK(in_arity);
    struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(callee);

    if (c->kind == jitterlisp_closure_type_compiled)
      {
        /* Make place for the return address in the return stack.  The
           actual value will be written by the callee. */
        JITTER_PUSH_UNSPECIFIED_RETURNSTACK();

        /* Branch-and-link to the native code, whose first instruction
           will be a prolog. */
        struct jitterlisp_compiled_closure *cc = & c->compiled;
        JITTER_BRANCH_AND_LINK(cc->first_program_point);
      }
    else
      {
        const struct jitterlisp_interpreted_closure *ic = & c->interpreted;

        /* Push an element on the main stack.  This way we can ensure that
           every actual is accessible thru memory in a contiguous array,
           even if the main stack is TOS-optimized.  Compute the address
           (on the main stack backing) where the actuals begin.

           Notice that the interpreted function we are calling is allowed
           to call into compiled code in its turn.  This is not a problem,
           as we are not moving stack pointers down until the call ends:
           the unused part of the main and return stacks is available to
           the callee. */
        JITTER_PUSH_UNSPECIFIED_MAINSTACK();
        jitterlisp_object *actuals
          // FIXME: add a stack operator to compute this address.
          = (& JITTER_UNDER_TOP_MAINSTACK()) - in_arity + 1;

        /* Call the interpreter. */
        jitterlisp_object interpretation_result
          = jitterlisp_call_interpreted (ic, actuals, in_arity);

        /* Remove as many elements as the in-arity plus one (the callee) from
           the stack, without affecting the top.  Unless JITTER_ARGN0 is
           residual this whole loops compiles to one instruction when the main
           stack is TOS-optimized, and doesn't touch memory. */
        int i;
        for (i = 0; i < in_arity + 1; i ++)
          JITTER_NIP_MAINSTACK();

        /* Now the stack is one element higher than it was before the call,
           containing the unspecified element at the top.  Replace it with
           the result.  Again this doesn't touch memory. */
        JITTER_TOP_MAINSTACK() = interpretation_result;
      }
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for call/n10/retR . */

  //fprintf (stderr, "..Executed instruction %s\n", "call/n10/retR");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the call/n10/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#if    defined(JITTER_DISPATCH_NO_THREADING)         \
    && ! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)
# undef _JITTER_RETURN_ADDRESS
#endif

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(call/n10/retR, call__n10__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for call/n10/retR, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction call/nR/retR */
  JITTER_INSTRUCTION_PROLOG_(call/nR/retR, call__nR__retR, cold)
  { /* This block begins with definitions for call/nR/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       43
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         call/nR/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "call"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "call/nR/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME call__nR__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is a non-replacement and a caller.
       Its 1-th argument, a literal, is the return address where to jump
       back after the procedure returns.  Branch-and-link
       functionality is enabled for this instruction. */
/* This instruction is relocatable: use more efficient branches
   which can generate defects. */
#   undef JITTER_BRANCH_AND_LINK
#   define JITTER_BRANCH_AND_LINK      _JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   define JITTER_BRANCH_AND_LINK_WITH _JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK
#   define JITTER_BRANCH_FAST_AND_LINK _JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 2

    /* The 0th argument is a residual literal. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1


#if defined(JITTER_DISPATCH_NO_THREADING)             \
    && (! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)  \
        || /* is this a replacement? */ 0)
  /* We use the implicit argument at the end of the calling.
     instruction to discover the procedure return address. */
  const void * const _jitter_return_pointer
    __attribute__ ((unused)) = JITTER_ARGP1;
  /* And make it accessible to the user (who will usually call 
     JITTER_BRANCH_AND_LINK) thru a nice macro. */
# define _JITTER_RETURN_ADDRESS _jitter_return_pointer
#endif

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of call/nR/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "call/nR/retR"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for call/nR/retR . */
  {
/* User-specified code, user code block part: beginning. */

    const jitter_uint in_arity = JITTER_ARGN0;
    jitterlisp_object callee = JITTER_AT_DEPTH_MAINSTACK(in_arity);
    struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(callee);

    if (c->kind == jitterlisp_closure_type_compiled)
      {
        /* Make place for the return address in the return stack.  The
           actual value will be written by the callee. */
        JITTER_PUSH_UNSPECIFIED_RETURNSTACK();

        /* Branch-and-link to the native code, whose first instruction
           will be a prolog. */
        struct jitterlisp_compiled_closure *cc = & c->compiled;
        JITTER_BRANCH_AND_LINK(cc->first_program_point);
      }
    else
      {
        const struct jitterlisp_interpreted_closure *ic = & c->interpreted;

        /* Push an element on the main stack.  This way we can ensure that
           every actual is accessible thru memory in a contiguous array,
           even if the main stack is TOS-optimized.  Compute the address
           (on the main stack backing) where the actuals begin.

           Notice that the interpreted function we are calling is allowed
           to call into compiled code in its turn.  This is not a problem,
           as we are not moving stack pointers down until the call ends:
           the unused part of the main and return stacks is available to
           the callee. */
        JITTER_PUSH_UNSPECIFIED_MAINSTACK();
        jitterlisp_object *actuals
          // FIXME: add a stack operator to compute this address.
          = (& JITTER_UNDER_TOP_MAINSTACK()) - in_arity + 1;

        /* Call the interpreter. */
        jitterlisp_object interpretation_result
          = jitterlisp_call_interpreted (ic, actuals, in_arity);

        /* Remove as many elements as the in-arity plus one (the callee) from
           the stack, without affecting the top.  Unless JITTER_ARGN0 is
           residual this whole loops compiles to one instruction when the main
           stack is TOS-optimized, and doesn't touch memory. */
        int i;
        for (i = 0; i < in_arity + 1; i ++)
          JITTER_NIP_MAINSTACK();

        /* Now the stack is one element higher than it was before the call,
           containing the unspecified element at the top.  Replace it with
           the result.  Again this doesn't touch memory. */
        JITTER_TOP_MAINSTACK() = interpretation_result;
      }
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for call/nR/retR . */

  //fprintf (stderr, "..Executed instruction %s\n", "call/nR/retR");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the call/nR/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#if    defined(JITTER_DISPATCH_NO_THREADING)         \
    && ! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)
# undef _JITTER_RETURN_ADDRESS
#endif

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(call/nR/retR, call__nR__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for call/nR/retR, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction call-compiled/n0/retR */
  JITTER_INSTRUCTION_PROLOG_(call-compiled/n0/retR, call_mcompiled__n0__retR, cold)
  { /* This block begins with definitions for call-compiled/n0/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       44
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         call-compiled/n0/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "call-compiled"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "call-compiled/n0/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME call_mcompiled__n0__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is a non-replacement and a caller.
       Its 1-th argument, a literal, is the return address where to jump
       back after the procedure returns.  Branch-and-link
       functionality is enabled for this instruction. */
/* This instruction is relocatable: use more efficient branches
   which can generate defects. */
#   undef JITTER_BRANCH_AND_LINK
#   define JITTER_BRANCH_AND_LINK      _JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   define JITTER_BRANCH_AND_LINK_WITH _JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK
#   define JITTER_BRANCH_FAST_AND_LINK _JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1

    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 0L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1


#if defined(JITTER_DISPATCH_NO_THREADING)             \
    && (! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)  \
        || /* is this a replacement? */ 0)
  /* We use the implicit argument at the end of the calling.
     instruction to discover the procedure return address. */
  const void * const _jitter_return_pointer
    __attribute__ ((unused)) = JITTER_ARGP1;
  /* And make it accessible to the user (who will usually call 
     JITTER_BRANCH_AND_LINK) thru a nice macro. */
# define _JITTER_RETURN_ADDRESS _jitter_return_pointer
#endif

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of call-compiled/n0/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "call-compiled/n0/retR"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for call-compiled/n0/retR . */
  {
/* User-specified code, user code block part: beginning. */

    const jitter_uint in_arity = JITTER_ARGN0;
    jitterlisp_object callee = JITTER_AT_DEPTH_MAINSTACK(in_arity);
    struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(callee);

    /* Here we can assume that * c is a compiled closure without checking. */
    struct jitterlisp_compiled_closure *cc = & c->compiled;

    /* Make place for the return address in the return stack.  The
       actual value will be written by the callee. */
    JITTER_PUSH_UNSPECIFIED_RETURNSTACK();
//    JITTER_TOP_RETURNSTACK() = 0x4242aaaa; // FIXME: just a test.  Remove.

    /* Branch-and-link to the native code, whose first instruction
       will be a prolog. */
    JITTER_BRANCH_AND_LINK(cc->first_program_point);
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for call-compiled/n0/retR . */

  //fprintf (stderr, "..Executed instruction %s\n", "call-compiled/n0/retR");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the call-compiled/n0/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#if    defined(JITTER_DISPATCH_NO_THREADING)         \
    && ! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)
# undef _JITTER_RETURN_ADDRESS
#endif

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(call-compiled/n0/retR, call_mcompiled__n0__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for call-compiled/n0/retR, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction call-compiled/n1/retR */
  JITTER_INSTRUCTION_PROLOG_(call-compiled/n1/retR, call_mcompiled__n1__retR, cold)
  { /* This block begins with definitions for call-compiled/n1/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       45
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         call-compiled/n1/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "call-compiled"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "call-compiled/n1/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME call_mcompiled__n1__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is a non-replacement and a caller.
       Its 1-th argument, a literal, is the return address where to jump
       back after the procedure returns.  Branch-and-link
       functionality is enabled for this instruction. */
/* This instruction is relocatable: use more efficient branches
   which can generate defects. */
#   undef JITTER_BRANCH_AND_LINK
#   define JITTER_BRANCH_AND_LINK      _JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   define JITTER_BRANCH_AND_LINK_WITH _JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK
#   define JITTER_BRANCH_FAST_AND_LINK _JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1

    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 1L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1


#if defined(JITTER_DISPATCH_NO_THREADING)             \
    && (! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)  \
        || /* is this a replacement? */ 0)
  /* We use the implicit argument at the end of the calling.
     instruction to discover the procedure return address. */
  const void * const _jitter_return_pointer
    __attribute__ ((unused)) = JITTER_ARGP1;
  /* And make it accessible to the user (who will usually call 
     JITTER_BRANCH_AND_LINK) thru a nice macro. */
# define _JITTER_RETURN_ADDRESS _jitter_return_pointer
#endif

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of call-compiled/n1/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "call-compiled/n1/retR"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for call-compiled/n1/retR . */
  {
/* User-specified code, user code block part: beginning. */

    const jitter_uint in_arity = JITTER_ARGN0;
    jitterlisp_object callee = JITTER_AT_DEPTH_MAINSTACK(in_arity);
    struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(callee);

    /* Here we can assume that * c is a compiled closure without checking. */
    struct jitterlisp_compiled_closure *cc = & c->compiled;

    /* Make place for the return address in the return stack.  The
       actual value will be written by the callee. */
    JITTER_PUSH_UNSPECIFIED_RETURNSTACK();
//    JITTER_TOP_RETURNSTACK() = 0x4242aaaa; // FIXME: just a test.  Remove.

    /* Branch-and-link to the native code, whose first instruction
       will be a prolog. */
    JITTER_BRANCH_AND_LINK(cc->first_program_point);
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for call-compiled/n1/retR . */

  //fprintf (stderr, "..Executed instruction %s\n", "call-compiled/n1/retR");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the call-compiled/n1/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#if    defined(JITTER_DISPATCH_NO_THREADING)         \
    && ! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)
# undef _JITTER_RETURN_ADDRESS
#endif

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(call-compiled/n1/retR, call_mcompiled__n1__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for call-compiled/n1/retR, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction call-compiled/n2/retR */
  JITTER_INSTRUCTION_PROLOG_(call-compiled/n2/retR, call_mcompiled__n2__retR, cold)
  { /* This block begins with definitions for call-compiled/n2/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       46
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         call-compiled/n2/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "call-compiled"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "call-compiled/n2/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME call_mcompiled__n2__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is a non-replacement and a caller.
       Its 1-th argument, a literal, is the return address where to jump
       back after the procedure returns.  Branch-and-link
       functionality is enabled for this instruction. */
/* This instruction is relocatable: use more efficient branches
   which can generate defects. */
#   undef JITTER_BRANCH_AND_LINK
#   define JITTER_BRANCH_AND_LINK      _JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   define JITTER_BRANCH_AND_LINK_WITH _JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK
#   define JITTER_BRANCH_FAST_AND_LINK _JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1

    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 2L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1


#if defined(JITTER_DISPATCH_NO_THREADING)             \
    && (! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)  \
        || /* is this a replacement? */ 0)
  /* We use the implicit argument at the end of the calling.
     instruction to discover the procedure return address. */
  const void * const _jitter_return_pointer
    __attribute__ ((unused)) = JITTER_ARGP1;
  /* And make it accessible to the user (who will usually call 
     JITTER_BRANCH_AND_LINK) thru a nice macro. */
# define _JITTER_RETURN_ADDRESS _jitter_return_pointer
#endif

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of call-compiled/n2/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "call-compiled/n2/retR"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for call-compiled/n2/retR . */
  {
/* User-specified code, user code block part: beginning. */

    const jitter_uint in_arity = JITTER_ARGN0;
    jitterlisp_object callee = JITTER_AT_DEPTH_MAINSTACK(in_arity);
    struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(callee);

    /* Here we can assume that * c is a compiled closure without checking. */
    struct jitterlisp_compiled_closure *cc = & c->compiled;

    /* Make place for the return address in the return stack.  The
       actual value will be written by the callee. */
    JITTER_PUSH_UNSPECIFIED_RETURNSTACK();
//    JITTER_TOP_RETURNSTACK() = 0x4242aaaa; // FIXME: just a test.  Remove.

    /* Branch-and-link to the native code, whose first instruction
       will be a prolog. */
    JITTER_BRANCH_AND_LINK(cc->first_program_point);
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for call-compiled/n2/retR . */

  //fprintf (stderr, "..Executed instruction %s\n", "call-compiled/n2/retR");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the call-compiled/n2/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#if    defined(JITTER_DISPATCH_NO_THREADING)         \
    && ! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)
# undef _JITTER_RETURN_ADDRESS
#endif

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(call-compiled/n2/retR, call_mcompiled__n2__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for call-compiled/n2/retR, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction call-compiled/n3/retR */
  JITTER_INSTRUCTION_PROLOG_(call-compiled/n3/retR, call_mcompiled__n3__retR, cold)
  { /* This block begins with definitions for call-compiled/n3/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       47
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         call-compiled/n3/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "call-compiled"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "call-compiled/n3/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME call_mcompiled__n3__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is a non-replacement and a caller.
       Its 1-th argument, a literal, is the return address where to jump
       back after the procedure returns.  Branch-and-link
       functionality is enabled for this instruction. */
/* This instruction is relocatable: use more efficient branches
   which can generate defects. */
#   undef JITTER_BRANCH_AND_LINK
#   define JITTER_BRANCH_AND_LINK      _JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   define JITTER_BRANCH_AND_LINK_WITH _JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK
#   define JITTER_BRANCH_FAST_AND_LINK _JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1

    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 3L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1


#if defined(JITTER_DISPATCH_NO_THREADING)             \
    && (! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)  \
        || /* is this a replacement? */ 0)
  /* We use the implicit argument at the end of the calling.
     instruction to discover the procedure return address. */
  const void * const _jitter_return_pointer
    __attribute__ ((unused)) = JITTER_ARGP1;
  /* And make it accessible to the user (who will usually call 
     JITTER_BRANCH_AND_LINK) thru a nice macro. */
# define _JITTER_RETURN_ADDRESS _jitter_return_pointer
#endif

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of call-compiled/n3/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "call-compiled/n3/retR"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for call-compiled/n3/retR . */
  {
/* User-specified code, user code block part: beginning. */

    const jitter_uint in_arity = JITTER_ARGN0;
    jitterlisp_object callee = JITTER_AT_DEPTH_MAINSTACK(in_arity);
    struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(callee);

    /* Here we can assume that * c is a compiled closure without checking. */
    struct jitterlisp_compiled_closure *cc = & c->compiled;

    /* Make place for the return address in the return stack.  The
       actual value will be written by the callee. */
    JITTER_PUSH_UNSPECIFIED_RETURNSTACK();
//    JITTER_TOP_RETURNSTACK() = 0x4242aaaa; // FIXME: just a test.  Remove.

    /* Branch-and-link to the native code, whose first instruction
       will be a prolog. */
    JITTER_BRANCH_AND_LINK(cc->first_program_point);
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for call-compiled/n3/retR . */

  //fprintf (stderr, "..Executed instruction %s\n", "call-compiled/n3/retR");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the call-compiled/n3/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#if    defined(JITTER_DISPATCH_NO_THREADING)         \
    && ! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)
# undef _JITTER_RETURN_ADDRESS
#endif

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(call-compiled/n3/retR, call_mcompiled__n3__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for call-compiled/n3/retR, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction call-compiled/n4/retR */
  JITTER_INSTRUCTION_PROLOG_(call-compiled/n4/retR, call_mcompiled__n4__retR, cold)
  { /* This block begins with definitions for call-compiled/n4/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       48
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         call-compiled/n4/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "call-compiled"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "call-compiled/n4/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME call_mcompiled__n4__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is a non-replacement and a caller.
       Its 1-th argument, a literal, is the return address where to jump
       back after the procedure returns.  Branch-and-link
       functionality is enabled for this instruction. */
/* This instruction is relocatable: use more efficient branches
   which can generate defects. */
#   undef JITTER_BRANCH_AND_LINK
#   define JITTER_BRANCH_AND_LINK      _JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   define JITTER_BRANCH_AND_LINK_WITH _JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK
#   define JITTER_BRANCH_FAST_AND_LINK _JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1

    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 4L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1


#if defined(JITTER_DISPATCH_NO_THREADING)             \
    && (! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)  \
        || /* is this a replacement? */ 0)
  /* We use the implicit argument at the end of the calling.
     instruction to discover the procedure return address. */
  const void * const _jitter_return_pointer
    __attribute__ ((unused)) = JITTER_ARGP1;
  /* And make it accessible to the user (who will usually call 
     JITTER_BRANCH_AND_LINK) thru a nice macro. */
# define _JITTER_RETURN_ADDRESS _jitter_return_pointer
#endif

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of call-compiled/n4/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "call-compiled/n4/retR"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for call-compiled/n4/retR . */
  {
/* User-specified code, user code block part: beginning. */

    const jitter_uint in_arity = JITTER_ARGN0;
    jitterlisp_object callee = JITTER_AT_DEPTH_MAINSTACK(in_arity);
    struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(callee);

    /* Here we can assume that * c is a compiled closure without checking. */
    struct jitterlisp_compiled_closure *cc = & c->compiled;

    /* Make place for the return address in the return stack.  The
       actual value will be written by the callee. */
    JITTER_PUSH_UNSPECIFIED_RETURNSTACK();
//    JITTER_TOP_RETURNSTACK() = 0x4242aaaa; // FIXME: just a test.  Remove.

    /* Branch-and-link to the native code, whose first instruction
       will be a prolog. */
    JITTER_BRANCH_AND_LINK(cc->first_program_point);
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for call-compiled/n4/retR . */

  //fprintf (stderr, "..Executed instruction %s\n", "call-compiled/n4/retR");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the call-compiled/n4/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#if    defined(JITTER_DISPATCH_NO_THREADING)         \
    && ! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)
# undef _JITTER_RETURN_ADDRESS
#endif

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(call-compiled/n4/retR, call_mcompiled__n4__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for call-compiled/n4/retR, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction call-compiled/n5/retR */
  JITTER_INSTRUCTION_PROLOG_(call-compiled/n5/retR, call_mcompiled__n5__retR, cold)
  { /* This block begins with definitions for call-compiled/n5/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       49
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         call-compiled/n5/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "call-compiled"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "call-compiled/n5/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME call_mcompiled__n5__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is a non-replacement and a caller.
       Its 1-th argument, a literal, is the return address where to jump
       back after the procedure returns.  Branch-and-link
       functionality is enabled for this instruction. */
/* This instruction is relocatable: use more efficient branches
   which can generate defects. */
#   undef JITTER_BRANCH_AND_LINK
#   define JITTER_BRANCH_AND_LINK      _JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   define JITTER_BRANCH_AND_LINK_WITH _JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK
#   define JITTER_BRANCH_FAST_AND_LINK _JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1

    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 5L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1


#if defined(JITTER_DISPATCH_NO_THREADING)             \
    && (! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)  \
        || /* is this a replacement? */ 0)
  /* We use the implicit argument at the end of the calling.
     instruction to discover the procedure return address. */
  const void * const _jitter_return_pointer
    __attribute__ ((unused)) = JITTER_ARGP1;
  /* And make it accessible to the user (who will usually call 
     JITTER_BRANCH_AND_LINK) thru a nice macro. */
# define _JITTER_RETURN_ADDRESS _jitter_return_pointer
#endif

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of call-compiled/n5/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "call-compiled/n5/retR"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for call-compiled/n5/retR . */
  {
/* User-specified code, user code block part: beginning. */

    const jitter_uint in_arity = JITTER_ARGN0;
    jitterlisp_object callee = JITTER_AT_DEPTH_MAINSTACK(in_arity);
    struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(callee);

    /* Here we can assume that * c is a compiled closure without checking. */
    struct jitterlisp_compiled_closure *cc = & c->compiled;

    /* Make place for the return address in the return stack.  The
       actual value will be written by the callee. */
    JITTER_PUSH_UNSPECIFIED_RETURNSTACK();
//    JITTER_TOP_RETURNSTACK() = 0x4242aaaa; // FIXME: just a test.  Remove.

    /* Branch-and-link to the native code, whose first instruction
       will be a prolog. */
    JITTER_BRANCH_AND_LINK(cc->first_program_point);
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for call-compiled/n5/retR . */

  //fprintf (stderr, "..Executed instruction %s\n", "call-compiled/n5/retR");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the call-compiled/n5/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#if    defined(JITTER_DISPATCH_NO_THREADING)         \
    && ! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)
# undef _JITTER_RETURN_ADDRESS
#endif

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(call-compiled/n5/retR, call_mcompiled__n5__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for call-compiled/n5/retR, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction call-compiled/n6/retR */
  JITTER_INSTRUCTION_PROLOG_(call-compiled/n6/retR, call_mcompiled__n6__retR, cold)
  { /* This block begins with definitions for call-compiled/n6/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       50
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         call-compiled/n6/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "call-compiled"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "call-compiled/n6/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME call_mcompiled__n6__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is a non-replacement and a caller.
       Its 1-th argument, a literal, is the return address where to jump
       back after the procedure returns.  Branch-and-link
       functionality is enabled for this instruction. */
/* This instruction is relocatable: use more efficient branches
   which can generate defects. */
#   undef JITTER_BRANCH_AND_LINK
#   define JITTER_BRANCH_AND_LINK      _JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   define JITTER_BRANCH_AND_LINK_WITH _JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK
#   define JITTER_BRANCH_FAST_AND_LINK _JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1

    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 6L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1


#if defined(JITTER_DISPATCH_NO_THREADING)             \
    && (! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)  \
        || /* is this a replacement? */ 0)
  /* We use the implicit argument at the end of the calling.
     instruction to discover the procedure return address. */
  const void * const _jitter_return_pointer
    __attribute__ ((unused)) = JITTER_ARGP1;
  /* And make it accessible to the user (who will usually call 
     JITTER_BRANCH_AND_LINK) thru a nice macro. */
# define _JITTER_RETURN_ADDRESS _jitter_return_pointer
#endif

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of call-compiled/n6/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "call-compiled/n6/retR"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for call-compiled/n6/retR . */
  {
/* User-specified code, user code block part: beginning. */

    const jitter_uint in_arity = JITTER_ARGN0;
    jitterlisp_object callee = JITTER_AT_DEPTH_MAINSTACK(in_arity);
    struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(callee);

    /* Here we can assume that * c is a compiled closure without checking. */
    struct jitterlisp_compiled_closure *cc = & c->compiled;

    /* Make place for the return address in the return stack.  The
       actual value will be written by the callee. */
    JITTER_PUSH_UNSPECIFIED_RETURNSTACK();
//    JITTER_TOP_RETURNSTACK() = 0x4242aaaa; // FIXME: just a test.  Remove.

    /* Branch-and-link to the native code, whose first instruction
       will be a prolog. */
    JITTER_BRANCH_AND_LINK(cc->first_program_point);
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for call-compiled/n6/retR . */

  //fprintf (stderr, "..Executed instruction %s\n", "call-compiled/n6/retR");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the call-compiled/n6/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#if    defined(JITTER_DISPATCH_NO_THREADING)         \
    && ! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)
# undef _JITTER_RETURN_ADDRESS
#endif

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(call-compiled/n6/retR, call_mcompiled__n6__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for call-compiled/n6/retR, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction call-compiled/n7/retR */
  JITTER_INSTRUCTION_PROLOG_(call-compiled/n7/retR, call_mcompiled__n7__retR, cold)
  { /* This block begins with definitions for call-compiled/n7/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       51
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         call-compiled/n7/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "call-compiled"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "call-compiled/n7/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME call_mcompiled__n7__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is a non-replacement and a caller.
       Its 1-th argument, a literal, is the return address where to jump
       back after the procedure returns.  Branch-and-link
       functionality is enabled for this instruction. */
/* This instruction is relocatable: use more efficient branches
   which can generate defects. */
#   undef JITTER_BRANCH_AND_LINK
#   define JITTER_BRANCH_AND_LINK      _JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   define JITTER_BRANCH_AND_LINK_WITH _JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK
#   define JITTER_BRANCH_FAST_AND_LINK _JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1

    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 7L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1


#if defined(JITTER_DISPATCH_NO_THREADING)             \
    && (! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)  \
        || /* is this a replacement? */ 0)
  /* We use the implicit argument at the end of the calling.
     instruction to discover the procedure return address. */
  const void * const _jitter_return_pointer
    __attribute__ ((unused)) = JITTER_ARGP1;
  /* And make it accessible to the user (who will usually call 
     JITTER_BRANCH_AND_LINK) thru a nice macro. */
# define _JITTER_RETURN_ADDRESS _jitter_return_pointer
#endif

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of call-compiled/n7/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "call-compiled/n7/retR"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for call-compiled/n7/retR . */
  {
/* User-specified code, user code block part: beginning. */

    const jitter_uint in_arity = JITTER_ARGN0;
    jitterlisp_object callee = JITTER_AT_DEPTH_MAINSTACK(in_arity);
    struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(callee);

    /* Here we can assume that * c is a compiled closure without checking. */
    struct jitterlisp_compiled_closure *cc = & c->compiled;

    /* Make place for the return address in the return stack.  The
       actual value will be written by the callee. */
    JITTER_PUSH_UNSPECIFIED_RETURNSTACK();
//    JITTER_TOP_RETURNSTACK() = 0x4242aaaa; // FIXME: just a test.  Remove.

    /* Branch-and-link to the native code, whose first instruction
       will be a prolog. */
    JITTER_BRANCH_AND_LINK(cc->first_program_point);
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for call-compiled/n7/retR . */

  //fprintf (stderr, "..Executed instruction %s\n", "call-compiled/n7/retR");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the call-compiled/n7/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#if    defined(JITTER_DISPATCH_NO_THREADING)         \
    && ! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)
# undef _JITTER_RETURN_ADDRESS
#endif

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(call-compiled/n7/retR, call_mcompiled__n7__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for call-compiled/n7/retR, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction call-compiled/n8/retR */
  JITTER_INSTRUCTION_PROLOG_(call-compiled/n8/retR, call_mcompiled__n8__retR, cold)
  { /* This block begins with definitions for call-compiled/n8/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       52
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         call-compiled/n8/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "call-compiled"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "call-compiled/n8/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME call_mcompiled__n8__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is a non-replacement and a caller.
       Its 1-th argument, a literal, is the return address where to jump
       back after the procedure returns.  Branch-and-link
       functionality is enabled for this instruction. */
/* This instruction is relocatable: use more efficient branches
   which can generate defects. */
#   undef JITTER_BRANCH_AND_LINK
#   define JITTER_BRANCH_AND_LINK      _JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   define JITTER_BRANCH_AND_LINK_WITH _JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK
#   define JITTER_BRANCH_FAST_AND_LINK _JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1

    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 8L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1


#if defined(JITTER_DISPATCH_NO_THREADING)             \
    && (! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)  \
        || /* is this a replacement? */ 0)
  /* We use the implicit argument at the end of the calling.
     instruction to discover the procedure return address. */
  const void * const _jitter_return_pointer
    __attribute__ ((unused)) = JITTER_ARGP1;
  /* And make it accessible to the user (who will usually call 
     JITTER_BRANCH_AND_LINK) thru a nice macro. */
# define _JITTER_RETURN_ADDRESS _jitter_return_pointer
#endif

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of call-compiled/n8/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "call-compiled/n8/retR"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for call-compiled/n8/retR . */
  {
/* User-specified code, user code block part: beginning. */

    const jitter_uint in_arity = JITTER_ARGN0;
    jitterlisp_object callee = JITTER_AT_DEPTH_MAINSTACK(in_arity);
    struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(callee);

    /* Here we can assume that * c is a compiled closure without checking. */
    struct jitterlisp_compiled_closure *cc = & c->compiled;

    /* Make place for the return address in the return stack.  The
       actual value will be written by the callee. */
    JITTER_PUSH_UNSPECIFIED_RETURNSTACK();
//    JITTER_TOP_RETURNSTACK() = 0x4242aaaa; // FIXME: just a test.  Remove.

    /* Branch-and-link to the native code, whose first instruction
       will be a prolog. */
    JITTER_BRANCH_AND_LINK(cc->first_program_point);
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for call-compiled/n8/retR . */

  //fprintf (stderr, "..Executed instruction %s\n", "call-compiled/n8/retR");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the call-compiled/n8/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#if    defined(JITTER_DISPATCH_NO_THREADING)         \
    && ! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)
# undef _JITTER_RETURN_ADDRESS
#endif

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(call-compiled/n8/retR, call_mcompiled__n8__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for call-compiled/n8/retR, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction call-compiled/n9/retR */
  JITTER_INSTRUCTION_PROLOG_(call-compiled/n9/retR, call_mcompiled__n9__retR, cold)
  { /* This block begins with definitions for call-compiled/n9/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       53
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         call-compiled/n9/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "call-compiled"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "call-compiled/n9/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME call_mcompiled__n9__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is a non-replacement and a caller.
       Its 1-th argument, a literal, is the return address where to jump
       back after the procedure returns.  Branch-and-link
       functionality is enabled for this instruction. */
/* This instruction is relocatable: use more efficient branches
   which can generate defects. */
#   undef JITTER_BRANCH_AND_LINK
#   define JITTER_BRANCH_AND_LINK      _JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   define JITTER_BRANCH_AND_LINK_WITH _JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK
#   define JITTER_BRANCH_FAST_AND_LINK _JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1

    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 9L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1


#if defined(JITTER_DISPATCH_NO_THREADING)             \
    && (! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)  \
        || /* is this a replacement? */ 0)
  /* We use the implicit argument at the end of the calling.
     instruction to discover the procedure return address. */
  const void * const _jitter_return_pointer
    __attribute__ ((unused)) = JITTER_ARGP1;
  /* And make it accessible to the user (who will usually call 
     JITTER_BRANCH_AND_LINK) thru a nice macro. */
# define _JITTER_RETURN_ADDRESS _jitter_return_pointer
#endif

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of call-compiled/n9/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "call-compiled/n9/retR"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for call-compiled/n9/retR . */
  {
/* User-specified code, user code block part: beginning. */

    const jitter_uint in_arity = JITTER_ARGN0;
    jitterlisp_object callee = JITTER_AT_DEPTH_MAINSTACK(in_arity);
    struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(callee);

    /* Here we can assume that * c is a compiled closure without checking. */
    struct jitterlisp_compiled_closure *cc = & c->compiled;

    /* Make place for the return address in the return stack.  The
       actual value will be written by the callee. */
    JITTER_PUSH_UNSPECIFIED_RETURNSTACK();
//    JITTER_TOP_RETURNSTACK() = 0x4242aaaa; // FIXME: just a test.  Remove.

    /* Branch-and-link to the native code, whose first instruction
       will be a prolog. */
    JITTER_BRANCH_AND_LINK(cc->first_program_point);
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for call-compiled/n9/retR . */

  //fprintf (stderr, "..Executed instruction %s\n", "call-compiled/n9/retR");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the call-compiled/n9/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#if    defined(JITTER_DISPATCH_NO_THREADING)         \
    && ! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)
# undef _JITTER_RETURN_ADDRESS
#endif

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(call-compiled/n9/retR, call_mcompiled__n9__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for call-compiled/n9/retR, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction call-compiled/n10/retR */
  JITTER_INSTRUCTION_PROLOG_(call-compiled/n10/retR, call_mcompiled__n10__retR, cold)
  { /* This block begins with definitions for call-compiled/n10/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       54
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         call-compiled/n10/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "call-compiled"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "call-compiled/n10/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME call_mcompiled__n10__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is a non-replacement and a caller.
       Its 1-th argument, a literal, is the return address where to jump
       back after the procedure returns.  Branch-and-link
       functionality is enabled for this instruction. */
/* This instruction is relocatable: use more efficient branches
   which can generate defects. */
#   undef JITTER_BRANCH_AND_LINK
#   define JITTER_BRANCH_AND_LINK      _JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   define JITTER_BRANCH_AND_LINK_WITH _JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK
#   define JITTER_BRANCH_FAST_AND_LINK _JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1

    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 10L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1


#if defined(JITTER_DISPATCH_NO_THREADING)             \
    && (! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)  \
        || /* is this a replacement? */ 0)
  /* We use the implicit argument at the end of the calling.
     instruction to discover the procedure return address. */
  const void * const _jitter_return_pointer
    __attribute__ ((unused)) = JITTER_ARGP1;
  /* And make it accessible to the user (who will usually call 
     JITTER_BRANCH_AND_LINK) thru a nice macro. */
# define _JITTER_RETURN_ADDRESS _jitter_return_pointer
#endif

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of call-compiled/n10/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "call-compiled/n10/retR"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for call-compiled/n10/retR . */
  {
/* User-specified code, user code block part: beginning. */

    const jitter_uint in_arity = JITTER_ARGN0;
    jitterlisp_object callee = JITTER_AT_DEPTH_MAINSTACK(in_arity);
    struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(callee);

    /* Here we can assume that * c is a compiled closure without checking. */
    struct jitterlisp_compiled_closure *cc = & c->compiled;

    /* Make place for the return address in the return stack.  The
       actual value will be written by the callee. */
    JITTER_PUSH_UNSPECIFIED_RETURNSTACK();
//    JITTER_TOP_RETURNSTACK() = 0x4242aaaa; // FIXME: just a test.  Remove.

    /* Branch-and-link to the native code, whose first instruction
       will be a prolog. */
    JITTER_BRANCH_AND_LINK(cc->first_program_point);
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for call-compiled/n10/retR . */

  //fprintf (stderr, "..Executed instruction %s\n", "call-compiled/n10/retR");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the call-compiled/n10/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#if    defined(JITTER_DISPATCH_NO_THREADING)         \
    && ! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)
# undef _JITTER_RETURN_ADDRESS
#endif

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(call-compiled/n10/retR, call_mcompiled__n10__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for call-compiled/n10/retR, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction call-compiled/nR/retR */
  JITTER_INSTRUCTION_PROLOG_(call-compiled/nR/retR, call_mcompiled__nR__retR, cold)
  { /* This block begins with definitions for call-compiled/nR/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       55
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         call-compiled/nR/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "call-compiled"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "call-compiled/nR/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME call_mcompiled__nR__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is a non-replacement and a caller.
       Its 1-th argument, a literal, is the return address where to jump
       back after the procedure returns.  Branch-and-link
       functionality is enabled for this instruction. */
/* This instruction is relocatable: use more efficient branches
   which can generate defects. */
#   undef JITTER_BRANCH_AND_LINK
#   define JITTER_BRANCH_AND_LINK      _JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   define JITTER_BRANCH_AND_LINK_WITH _JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK
#   define JITTER_BRANCH_FAST_AND_LINK _JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 2

    /* The 0th argument is a residual literal. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1


#if defined(JITTER_DISPATCH_NO_THREADING)             \
    && (! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)  \
        || /* is this a replacement? */ 0)
  /* We use the implicit argument at the end of the calling.
     instruction to discover the procedure return address. */
  const void * const _jitter_return_pointer
    __attribute__ ((unused)) = JITTER_ARGP1;
  /* And make it accessible to the user (who will usually call 
     JITTER_BRANCH_AND_LINK) thru a nice macro. */
# define _JITTER_RETURN_ADDRESS _jitter_return_pointer
#endif

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of call-compiled/nR/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "call-compiled/nR/retR"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for call-compiled/nR/retR . */
  {
/* User-specified code, user code block part: beginning. */

    const jitter_uint in_arity = JITTER_ARGN0;
    jitterlisp_object callee = JITTER_AT_DEPTH_MAINSTACK(in_arity);
    struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(callee);

    /* Here we can assume that * c is a compiled closure without checking. */
    struct jitterlisp_compiled_closure *cc = & c->compiled;

    /* Make place for the return address in the return stack.  The
       actual value will be written by the callee. */
    JITTER_PUSH_UNSPECIFIED_RETURNSTACK();
//    JITTER_TOP_RETURNSTACK() = 0x4242aaaa; // FIXME: just a test.  Remove.

    /* Branch-and-link to the native code, whose first instruction
       will be a prolog. */
    JITTER_BRANCH_AND_LINK(cc->first_program_point);
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for call-compiled/nR/retR . */

  //fprintf (stderr, "..Executed instruction %s\n", "call-compiled/nR/retR");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the call-compiled/nR/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#if    defined(JITTER_DISPATCH_NO_THREADING)         \
    && ! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)
# undef _JITTER_RETURN_ADDRESS
#endif

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(call-compiled/nR/retR, call_mcompiled__nR__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for call-compiled/nR/retR, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction call-from-c/retR */
  JITTER_INSTRUCTION_PROLOG_(call-from-c/retR, call_mfrom_mc__retR, cold)
  { /* This block begins with definitions for call-from-c/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       56
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         call-from-c/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "call-from-c"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "call-from-c/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME call_mfrom_mc__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is a non-replacement and a caller.
       Its 0-th argument, a literal, is the return address where to jump
       back after the procedure returns.  Branch-and-link
       functionality is enabled for this instruction. */
/* This instruction is relocatable: use more efficient branches
   which can generate defects. */
#   undef JITTER_BRANCH_AND_LINK
#   define JITTER_BRANCH_AND_LINK      _JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   define JITTER_BRANCH_AND_LINK_WITH _JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK
#   define JITTER_BRANCH_FAST_AND_LINK _JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1

    /* The 0th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0


#if defined(JITTER_DISPATCH_NO_THREADING)             \
    && (! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)  \
        || /* is this a replacement? */ 0)
  /* We use the implicit argument at the end of the calling.
     instruction to discover the procedure return address. */
  const void * const _jitter_return_pointer
    __attribute__ ((unused)) = JITTER_ARGP0;
  /* And make it accessible to the user (who will usually call 
     JITTER_BRANCH_AND_LINK) thru a nice macro. */
# define _JITTER_RETURN_ADDRESS _jitter_return_pointer
#endif

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of call-from-c/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "call-from-c/retR"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for call-from-c/retR . */
  {
/* User-specified code, user code block part: beginning. */

    /* Get a number (untagged) from the stack top, so that I know at which
       depth to find the closure.  The arity check must have been
       performed already on the interpreter side. */
    const jitter_uint in_arity_plus_one = JITTER_TOP_MAINSTACK();

    /* What follows is similar to the call instruction in the case of a compiled
       callee.  Shall I factor the common code with a macro? */

    /* Decode the closure. */
    jitterlisp_object callee
      = JITTER_AT_NONZERO_DEPTH_MAINSTACK(in_arity_plus_one);
    struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(callee);
    struct jitterlisp_compiled_closure *cc = & c->compiled;

    /* Drop the number of arguments. */
    JITTER_DROP_MAINSTACK();

    /* Make place for the return address in the return stack.  The
       actual value will be written by the callee. */
    JITTER_PUSH_UNSPECIFIED_RETURNSTACK();

    /* Branch-and-link.  This follows the ordinary calling convention,
       with the main stack containing the closure and its actuals, known
       to be in the correct number.  The next VM instruction will be a
       prolog saving the link; then execution will fall thru into the
       compiled closure body. */
    JITTER_BRANCH_AND_LINK(cc->first_program_point);
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for call-from-c/retR . */

  //fprintf (stderr, "..Executed instruction %s\n", "call-from-c/retR");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the call-from-c/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#if    defined(JITTER_DISPATCH_NO_THREADING)         \
    && ! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)
# undef _JITTER_RETURN_ADDRESS
#endif

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(call-from-c/retR, call_mfrom_mc__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for call-from-c/retR, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction canonicalize-boolean */
  JITTER_INSTRUCTION_PROLOG_(canonicalize-boolean, canonicalize_mboolean, hot)
  { /* This block begins with definitions for canonicalize-boolean . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       57
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         canonicalize-boolean
#   define JITTER_INSTRUCTION_NAME_AS_STRING "canonicalize-boolean"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "canonicalize-boolean"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME canonicalize_mboolean

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is not branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is not branching: undefine branch
       macros so that they cannot be used by mistake. */
/* Locally poison JITTER_COMPUTED_GOTO . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_COMPUTED_GOTO")
# undef JITTER_COMPUTED_GOTO
# define JITTER_COMPUTED_GOTO JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_COMPUTED_GOTO, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_COMPUTED_GOTO
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_COMPUTED_GOTO . */

/* Locally poison JITTER_BRANCH . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_BRANCH")
# undef JITTER_BRANCH
# define JITTER_BRANCH JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_BRANCH, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_BRANCH
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_BRANCH . */

/* Locally poison JITTER_EXIT . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_EXIT")
# undef JITTER_EXIT
# define JITTER_EXIT JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_EXIT, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_EXIT
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_EXIT . */

  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0


#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of canonicalize-boolean ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "canonicalize-boolean"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for canonicalize-boolean . */
  {
/* User-specified code, user code block part: beginning. */

    JITTERLISP_BOOLEAN_CANONICALIZE_(JITTER_TOP_MAINSTACK(),
                                     JITTER_TOP_MAINSTACK());
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for canonicalize-boolean . */

  //fprintf (stderr, "..Executed instruction %s\n", "canonicalize-boolean");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the canonicalize-boolean argument macros so they can't be used
       by mistake in the instruction body coming next. */

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_EXIT")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_BRANCH")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_COMPUTED_GOTO")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(canonicalize-boolean, canonicalize_mboolean, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for canonicalize-boolean, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction cdr-register/%rR/%rR/fR */
  JITTER_INSTRUCTION_PROLOG_(cdr-register/%rR/%rR/fR, cdr_mregister___rrR___rrR__fR, cold)
  { /* This block begins with definitions for cdr-register/%rR/%rR/fR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       58
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         cdr-register/%rR/%rR/fR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "cdr-register"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "cdr-register/%rR/%rR/fR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME cdr_mregister___rrR___rrR__fR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity varies depending on whether we have fast labels. */
#ifdef JITTER_HAVE_PATCH_IN
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 2
#else
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 3
#endif // #ifdef JITTER_HAVE_PATCH_IN

  /* Define argument-access macros for cdr-register/%rR/%rR/fR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a slow (therefore residual, passed as an offset)
        register. */
  /* Define a macro expanding to the slow register offset. */
#if defined(JITTER_DISPATCH_NO_THREADING)
# define JITTER_SLOW_REGISTER_OFFSET0 (JITTER_RESIDUAL_ARGUMENT_0.fixnum)
#elif defined (JITTER_DISPATCH_MINIMAL_THREADING)
# define JITTER_SLOW_REGISTER_OFFSET0 ((((union jitter_word*)jitter_ip)[0]).fixnum)
#else
# define JITTER_SLOW_REGISTER_OFFSET0 ((((union jitter_word*)jitter_ip)[1]).fixnum)
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
  /* Define a macro expanding to an l-value for the VM register content. */
#   define JITTER_ARG0  JITTER_SLOW_REGISTER_FROM_OFFSET(r, JITTER_SLOW_REGISTER_OFFSET0)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)

    /* The 1th argument is a slow (therefore residual, passed as an offset)
        register. */
  /* Define a macro expanding to the slow register offset. */
#if defined(JITTER_DISPATCH_NO_THREADING)
# define JITTER_SLOW_REGISTER_OFFSET1 (JITTER_RESIDUAL_ARGUMENT_1.fixnum)
#elif defined (JITTER_DISPATCH_MINIMAL_THREADING)
# define JITTER_SLOW_REGISTER_OFFSET1 ((((union jitter_word*)jitter_ip)[1]).fixnum)
#else
# define JITTER_SLOW_REGISTER_OFFSET1 ((((union jitter_word*)jitter_ip)[2]).fixnum)
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
  /* Define a macro expanding to an l-value for the VM register content. */
#   define JITTER_ARG1  JITTER_SLOW_REGISTER_FROM_OFFSET(r, JITTER_SLOW_REGISTER_OFFSET1)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)

    /* The 2th argument is a "residual" fast label.  Define its
       _ARGF macro as the residual *index* (counting only fast labels, 0-based),
       so that at replication time we know what instruction address to patch in. */
#   define JITTER_ARGF2 0
    /* JITTER_ARG2 is intentionally not defined for a fast label. */

#   define JITTER_ARGN2 (JITTER_ARG2.fixnum)
#   define JITTER_ARGU2 (JITTER_ARG2.ufixnum)
#   define JITTER_ARGP2 (JITTER_ARG2.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
    /* The 0th argument is a slow (therefore residual, passed as an offset)
        register. */
  /* Define a macro expanding to the slow register offset. */
#if defined(JITTER_DISPATCH_NO_THREADING)
# define JITTER_SLOW_REGISTER_OFFSET0 (JITTER_RESIDUAL_ARGUMENT_0.fixnum)
#elif defined (JITTER_DISPATCH_MINIMAL_THREADING)
# define JITTER_SLOW_REGISTER_OFFSET0 ((((union jitter_word*)jitter_ip)[0]).fixnum)
#else
# define JITTER_SLOW_REGISTER_OFFSET0 ((((union jitter_word*)jitter_ip)[1]).fixnum)
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
  /* Define a macro expanding to an l-value for the VM register content. */
#   define JITTER_ARG0  JITTER_SLOW_REGISTER_FROM_OFFSET(r, JITTER_SLOW_REGISTER_OFFSET0)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a slow (therefore residual, passed as an offset)
        register. */
  /* Define a macro expanding to the slow register offset. */
#if defined(JITTER_DISPATCH_NO_THREADING)
# define JITTER_SLOW_REGISTER_OFFSET1 (JITTER_RESIDUAL_ARGUMENT_1.fixnum)
#elif defined (JITTER_DISPATCH_MINIMAL_THREADING)
# define JITTER_SLOW_REGISTER_OFFSET1 ((((union jitter_word*)jitter_ip)[1]).fixnum)
#else
# define JITTER_SLOW_REGISTER_OFFSET1 ((((union jitter_word*)jitter_ip)[2]).fixnum)
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
  /* Define a macro expanding to an l-value for the VM register content. */
#   define JITTER_ARG1  JITTER_SLOW_REGISTER_FROM_OFFSET(r, JITTER_SLOW_REGISTER_OFFSET1)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG2  JITTER_RESIDUAL_ARGUMENT_2
    JITTER_MARK_RESIDUAL_2_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[2])
#else
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[3])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN2 (JITTER_ARG2.fixnum)
#   define JITTER_ARGU2 (JITTER_ARG2.ufixnum)
#   define JITTER_ARGP2 (JITTER_ARG2.pointer)
#   define JITTER_ARGF2 JITTER_ARGP2

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of cdr-register/%rR/%rR/fR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "cdr-register/%rR/%rR/fR"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for cdr-register/%rR/%rR/fR . */
  {
/* User-specified code, user code block part: beginning. */

#if ! defined (JITTERLISP_UNSAFE)
    JITTERLISP_BRANCH_FAST_UNLESS_CONS (JITTER_ARG0, JITTER_ARGF2);
#endif
    JITTERLISP_CDR_(JITTER_ARG1,
                    JITTER_ARG0);
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for cdr-register/%rR/%rR/fR . */

  //fprintf (stderr, "..Executed instruction %s\n", "cdr-register/%rR/%rR/fR");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the cdr-register/%rR/%rR/fR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1
#   undef JITTER_SLOW_REGISTER_OFFSET2
#   undef JITTER_ARG2
#   undef JITTER_ARGN2
#   undef JITTER_ARGU2
#   undef JITTER_ARGP2
#   undef JITTER_ARGF2

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(cdr-register/%rR/%rR/fR, cdr_mregister___rrR___rrR__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for cdr-register/%rR/%rR/fR, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction check-closure/fR */
  JITTER_INSTRUCTION_PROLOG_(check-closure/fR, check_mclosure__fR, hot)
  { /* This block begins with definitions for check-closure/fR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       59
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         check-closure/fR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "check-closure"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "check-closure/fR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME check_mclosure__fR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity varies depending on whether we have fast labels. */
#ifdef JITTER_HAVE_PATCH_IN
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
#else
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
#endif // #ifdef JITTER_HAVE_PATCH_IN

  /* Define argument-access macros for check-closure/fR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a "residual" fast label.  Define its
       _ARGF macro as the residual *index* (counting only fast labels, 0-based),
       so that at replication time we know what instruction address to patch in. */
#   define JITTER_ARGF0 0
    /* JITTER_ARG0 is intentionally not defined for a fast label. */

#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of check-closure/fR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "check-closure/fR"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for check-closure/fR . */
  {
/* User-specified code, user code block part: beginning. */

#   ifndef JITTERLISP_UNSAFE
      jitterlisp_object top = JITTER_TOP_MAINSTACK();
      if (! JITTERLISP_IS_CLOSURE(top))
        JITTER_BRANCH_FAST(JITTER_ARGF0);
#   endif // #ifndef JITTERLISP_UNSAFE
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for check-closure/fR . */

  //fprintf (stderr, "..Executed instruction %s\n", "check-closure/fR");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the check-closure/fR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(check-closure/fR, check_mclosure__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for check-closure/fR, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction check-global-defined/nR/fR */
  JITTER_INSTRUCTION_PROLOG_(check-global-defined/nR/fR, check_mglobal_mdefined__nR__fR, cold)
  { /* This block begins with definitions for check-global-defined/nR/fR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       60
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         check-global-defined/nR/fR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "check-global-defined"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "check-global-defined/nR/fR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME check_mglobal_mdefined__nR__fR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity varies depending on whether we have fast labels. */
#ifdef JITTER_HAVE_PATCH_IN
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
#else
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 2
#endif // #ifdef JITTER_HAVE_PATCH_IN

  /* Define argument-access macros for check-global-defined/nR/fR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a residual literal. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)

    /* The 1th argument is a "residual" fast label.  Define its
       _ARGF macro as the residual *index* (counting only fast labels, 0-based),
       so that at replication time we know what instruction address to patch in. */
#   define JITTER_ARGF1 0
    /* JITTER_ARG1 is intentionally not defined for a fast label. */

#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
    /* The 0th argument is a residual literal. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of check-global-defined/nR/fR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "check-global-defined/nR/fR"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for check-global-defined/nR/fR . */
  {
/* User-specified code, user code block part: beginning. */

#ifndef JITTERLISP_UNSAFE
    jitterlisp_object tagged_symbol = JITTER_ARGN0;
    struct jitterlisp_symbol * symbol = JITTERLISP_SYMBOL_DECODE(tagged_symbol);
    JITTER_BRANCH_FAST_IF_EQUAL (symbol->global_value, JITTERLISP_UNDEFINED,
                                 JITTER_ARGF1);
#endif // #ifndef JITTERLISP_UNSAFE
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for check-global-defined/nR/fR . */

  //fprintf (stderr, "..Executed instruction %s\n", "check-global-defined/nR/fR");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the check-global-defined/nR/fR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(check-global-defined/nR/fR, check_mglobal_mdefined__nR__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for check-global-defined/nR/fR, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction check-in-arity/n0/fR */
  JITTER_INSTRUCTION_PROLOG_(check-in-arity/n0/fR, check_min_marity__n0__fR, hot)
  { /* This block begins with definitions for check-in-arity/n0/fR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       61
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         check-in-arity/n0/fR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "check-in-arity"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "check-in-arity/n0/fR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME check_min_marity__n0__fR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity varies depending on whether we have fast labels. */
#ifdef JITTER_HAVE_PATCH_IN
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
#else
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
#endif // #ifdef JITTER_HAVE_PATCH_IN

  /* Define argument-access macros for check-in-arity/n0/fR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 0L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)

    /* The 1th argument is a "residual" fast label.  Define its
       _ARGF macro as the residual *index* (counting only fast labels, 0-based),
       so that at replication time we know what instruction address to patch in. */
#   define JITTER_ARGF1 0
    /* JITTER_ARG1 is intentionally not defined for a fast label. */

#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 0L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of check-in-arity/n0/fR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "check-in-arity/n0/fR"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for check-in-arity/n0/fR . */
  {
/* User-specified code, user code block part: beginning. */

#   ifndef JITTERLISP_UNSAFE
      /* Here we can assume that the top object is a closure, without checking:
         we either already performed a type check, or the compiler decided it
         wasn't necessary. */
      jitterlisp_object top = JITTER_TOP_MAINSTACK();
      struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(top);

      JITTER_BRANCH_FAST_IF_NOTEQUAL(c->in_arity, JITTER_ARGN0, JITTER_ARGF1);
#   endif // #ifndef JITTERLISP_UNSAFE
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for check-in-arity/n0/fR . */

  //fprintf (stderr, "..Executed instruction %s\n", "check-in-arity/n0/fR");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the check-in-arity/n0/fR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(check-in-arity/n0/fR, check_min_marity__n0__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for check-in-arity/n0/fR, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction check-in-arity/n1/fR */
  JITTER_INSTRUCTION_PROLOG_(check-in-arity/n1/fR, check_min_marity__n1__fR, hot)
  { /* This block begins with definitions for check-in-arity/n1/fR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       62
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         check-in-arity/n1/fR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "check-in-arity"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "check-in-arity/n1/fR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME check_min_marity__n1__fR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity varies depending on whether we have fast labels. */
#ifdef JITTER_HAVE_PATCH_IN
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
#else
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
#endif // #ifdef JITTER_HAVE_PATCH_IN

  /* Define argument-access macros for check-in-arity/n1/fR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 1L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)

    /* The 1th argument is a "residual" fast label.  Define its
       _ARGF macro as the residual *index* (counting only fast labels, 0-based),
       so that at replication time we know what instruction address to patch in. */
#   define JITTER_ARGF1 0
    /* JITTER_ARG1 is intentionally not defined for a fast label. */

#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 1L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of check-in-arity/n1/fR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "check-in-arity/n1/fR"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for check-in-arity/n1/fR . */
  {
/* User-specified code, user code block part: beginning. */

#   ifndef JITTERLISP_UNSAFE
      /* Here we can assume that the top object is a closure, without checking:
         we either already performed a type check, or the compiler decided it
         wasn't necessary. */
      jitterlisp_object top = JITTER_TOP_MAINSTACK();
      struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(top);

      JITTER_BRANCH_FAST_IF_NOTEQUAL(c->in_arity, JITTER_ARGN0, JITTER_ARGF1);
#   endif // #ifndef JITTERLISP_UNSAFE
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for check-in-arity/n1/fR . */

  //fprintf (stderr, "..Executed instruction %s\n", "check-in-arity/n1/fR");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the check-in-arity/n1/fR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(check-in-arity/n1/fR, check_min_marity__n1__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for check-in-arity/n1/fR, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction check-in-arity/n2/fR */
  JITTER_INSTRUCTION_PROLOG_(check-in-arity/n2/fR, check_min_marity__n2__fR, hot)
  { /* This block begins with definitions for check-in-arity/n2/fR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       63
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         check-in-arity/n2/fR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "check-in-arity"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "check-in-arity/n2/fR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME check_min_marity__n2__fR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity varies depending on whether we have fast labels. */
#ifdef JITTER_HAVE_PATCH_IN
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
#else
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
#endif // #ifdef JITTER_HAVE_PATCH_IN

  /* Define argument-access macros for check-in-arity/n2/fR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 2L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)

    /* The 1th argument is a "residual" fast label.  Define its
       _ARGF macro as the residual *index* (counting only fast labels, 0-based),
       so that at replication time we know what instruction address to patch in. */
#   define JITTER_ARGF1 0
    /* JITTER_ARG1 is intentionally not defined for a fast label. */

#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 2L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of check-in-arity/n2/fR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "check-in-arity/n2/fR"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for check-in-arity/n2/fR . */
  {
/* User-specified code, user code block part: beginning. */

#   ifndef JITTERLISP_UNSAFE
      /* Here we can assume that the top object is a closure, without checking:
         we either already performed a type check, or the compiler decided it
         wasn't necessary. */
      jitterlisp_object top = JITTER_TOP_MAINSTACK();
      struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(top);

      JITTER_BRANCH_FAST_IF_NOTEQUAL(c->in_arity, JITTER_ARGN0, JITTER_ARGF1);
#   endif // #ifndef JITTERLISP_UNSAFE
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for check-in-arity/n2/fR . */

  //fprintf (stderr, "..Executed instruction %s\n", "check-in-arity/n2/fR");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the check-in-arity/n2/fR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(check-in-arity/n2/fR, check_min_marity__n2__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for check-in-arity/n2/fR, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction check-in-arity/n3/fR */
  JITTER_INSTRUCTION_PROLOG_(check-in-arity/n3/fR, check_min_marity__n3__fR, hot)
  { /* This block begins with definitions for check-in-arity/n3/fR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       64
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         check-in-arity/n3/fR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "check-in-arity"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "check-in-arity/n3/fR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME check_min_marity__n3__fR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity varies depending on whether we have fast labels. */
#ifdef JITTER_HAVE_PATCH_IN
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
#else
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
#endif // #ifdef JITTER_HAVE_PATCH_IN

  /* Define argument-access macros for check-in-arity/n3/fR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 3L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)

    /* The 1th argument is a "residual" fast label.  Define its
       _ARGF macro as the residual *index* (counting only fast labels, 0-based),
       so that at replication time we know what instruction address to patch in. */
#   define JITTER_ARGF1 0
    /* JITTER_ARG1 is intentionally not defined for a fast label. */

#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 3L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of check-in-arity/n3/fR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "check-in-arity/n3/fR"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for check-in-arity/n3/fR . */
  {
/* User-specified code, user code block part: beginning. */

#   ifndef JITTERLISP_UNSAFE
      /* Here we can assume that the top object is a closure, without checking:
         we either already performed a type check, or the compiler decided it
         wasn't necessary. */
      jitterlisp_object top = JITTER_TOP_MAINSTACK();
      struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(top);

      JITTER_BRANCH_FAST_IF_NOTEQUAL(c->in_arity, JITTER_ARGN0, JITTER_ARGF1);
#   endif // #ifndef JITTERLISP_UNSAFE
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for check-in-arity/n3/fR . */

  //fprintf (stderr, "..Executed instruction %s\n", "check-in-arity/n3/fR");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the check-in-arity/n3/fR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(check-in-arity/n3/fR, check_min_marity__n3__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for check-in-arity/n3/fR, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction check-in-arity/n4/fR */
  JITTER_INSTRUCTION_PROLOG_(check-in-arity/n4/fR, check_min_marity__n4__fR, hot)
  { /* This block begins with definitions for check-in-arity/n4/fR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       65
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         check-in-arity/n4/fR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "check-in-arity"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "check-in-arity/n4/fR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME check_min_marity__n4__fR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity varies depending on whether we have fast labels. */
#ifdef JITTER_HAVE_PATCH_IN
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
#else
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
#endif // #ifdef JITTER_HAVE_PATCH_IN

  /* Define argument-access macros for check-in-arity/n4/fR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 4L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)

    /* The 1th argument is a "residual" fast label.  Define its
       _ARGF macro as the residual *index* (counting only fast labels, 0-based),
       so that at replication time we know what instruction address to patch in. */
#   define JITTER_ARGF1 0
    /* JITTER_ARG1 is intentionally not defined for a fast label. */

#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 4L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of check-in-arity/n4/fR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "check-in-arity/n4/fR"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for check-in-arity/n4/fR . */
  {
/* User-specified code, user code block part: beginning. */

#   ifndef JITTERLISP_UNSAFE
      /* Here we can assume that the top object is a closure, without checking:
         we either already performed a type check, or the compiler decided it
         wasn't necessary. */
      jitterlisp_object top = JITTER_TOP_MAINSTACK();
      struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(top);

      JITTER_BRANCH_FAST_IF_NOTEQUAL(c->in_arity, JITTER_ARGN0, JITTER_ARGF1);
#   endif // #ifndef JITTERLISP_UNSAFE
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for check-in-arity/n4/fR . */

  //fprintf (stderr, "..Executed instruction %s\n", "check-in-arity/n4/fR");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the check-in-arity/n4/fR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(check-in-arity/n4/fR, check_min_marity__n4__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for check-in-arity/n4/fR, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction check-in-arity/n5/fR */
  JITTER_INSTRUCTION_PROLOG_(check-in-arity/n5/fR, check_min_marity__n5__fR, hot)
  { /* This block begins with definitions for check-in-arity/n5/fR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       66
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         check-in-arity/n5/fR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "check-in-arity"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "check-in-arity/n5/fR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME check_min_marity__n5__fR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity varies depending on whether we have fast labels. */
#ifdef JITTER_HAVE_PATCH_IN
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
#else
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
#endif // #ifdef JITTER_HAVE_PATCH_IN

  /* Define argument-access macros for check-in-arity/n5/fR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 5L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)

    /* The 1th argument is a "residual" fast label.  Define its
       _ARGF macro as the residual *index* (counting only fast labels, 0-based),
       so that at replication time we know what instruction address to patch in. */
#   define JITTER_ARGF1 0
    /* JITTER_ARG1 is intentionally not defined for a fast label. */

#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 5L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of check-in-arity/n5/fR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "check-in-arity/n5/fR"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for check-in-arity/n5/fR . */
  {
/* User-specified code, user code block part: beginning. */

#   ifndef JITTERLISP_UNSAFE
      /* Here we can assume that the top object is a closure, without checking:
         we either already performed a type check, or the compiler decided it
         wasn't necessary. */
      jitterlisp_object top = JITTER_TOP_MAINSTACK();
      struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(top);

      JITTER_BRANCH_FAST_IF_NOTEQUAL(c->in_arity, JITTER_ARGN0, JITTER_ARGF1);
#   endif // #ifndef JITTERLISP_UNSAFE
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for check-in-arity/n5/fR . */

  //fprintf (stderr, "..Executed instruction %s\n", "check-in-arity/n5/fR");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the check-in-arity/n5/fR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(check-in-arity/n5/fR, check_min_marity__n5__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for check-in-arity/n5/fR, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction check-in-arity/n6/fR */
  JITTER_INSTRUCTION_PROLOG_(check-in-arity/n6/fR, check_min_marity__n6__fR, hot)
  { /* This block begins with definitions for check-in-arity/n6/fR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       67
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         check-in-arity/n6/fR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "check-in-arity"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "check-in-arity/n6/fR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME check_min_marity__n6__fR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity varies depending on whether we have fast labels. */
#ifdef JITTER_HAVE_PATCH_IN
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
#else
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
#endif // #ifdef JITTER_HAVE_PATCH_IN

  /* Define argument-access macros for check-in-arity/n6/fR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 6L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)

    /* The 1th argument is a "residual" fast label.  Define its
       _ARGF macro as the residual *index* (counting only fast labels, 0-based),
       so that at replication time we know what instruction address to patch in. */
#   define JITTER_ARGF1 0
    /* JITTER_ARG1 is intentionally not defined for a fast label. */

#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 6L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of check-in-arity/n6/fR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "check-in-arity/n6/fR"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for check-in-arity/n6/fR . */
  {
/* User-specified code, user code block part: beginning. */

#   ifndef JITTERLISP_UNSAFE
      /* Here we can assume that the top object is a closure, without checking:
         we either already performed a type check, or the compiler decided it
         wasn't necessary. */
      jitterlisp_object top = JITTER_TOP_MAINSTACK();
      struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(top);

      JITTER_BRANCH_FAST_IF_NOTEQUAL(c->in_arity, JITTER_ARGN0, JITTER_ARGF1);
#   endif // #ifndef JITTERLISP_UNSAFE
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for check-in-arity/n6/fR . */

  //fprintf (stderr, "..Executed instruction %s\n", "check-in-arity/n6/fR");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the check-in-arity/n6/fR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(check-in-arity/n6/fR, check_min_marity__n6__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for check-in-arity/n6/fR, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction check-in-arity/n7/fR */
  JITTER_INSTRUCTION_PROLOG_(check-in-arity/n7/fR, check_min_marity__n7__fR, hot)
  { /* This block begins with definitions for check-in-arity/n7/fR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       68
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         check-in-arity/n7/fR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "check-in-arity"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "check-in-arity/n7/fR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME check_min_marity__n7__fR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity varies depending on whether we have fast labels. */
#ifdef JITTER_HAVE_PATCH_IN
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
#else
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
#endif // #ifdef JITTER_HAVE_PATCH_IN

  /* Define argument-access macros for check-in-arity/n7/fR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 7L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)

    /* The 1th argument is a "residual" fast label.  Define its
       _ARGF macro as the residual *index* (counting only fast labels, 0-based),
       so that at replication time we know what instruction address to patch in. */
#   define JITTER_ARGF1 0
    /* JITTER_ARG1 is intentionally not defined for a fast label. */

#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 7L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of check-in-arity/n7/fR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "check-in-arity/n7/fR"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for check-in-arity/n7/fR . */
  {
/* User-specified code, user code block part: beginning. */

#   ifndef JITTERLISP_UNSAFE
      /* Here we can assume that the top object is a closure, without checking:
         we either already performed a type check, or the compiler decided it
         wasn't necessary. */
      jitterlisp_object top = JITTER_TOP_MAINSTACK();
      struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(top);

      JITTER_BRANCH_FAST_IF_NOTEQUAL(c->in_arity, JITTER_ARGN0, JITTER_ARGF1);
#   endif // #ifndef JITTERLISP_UNSAFE
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for check-in-arity/n7/fR . */

  //fprintf (stderr, "..Executed instruction %s\n", "check-in-arity/n7/fR");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the check-in-arity/n7/fR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(check-in-arity/n7/fR, check_min_marity__n7__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for check-in-arity/n7/fR, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction check-in-arity/n8/fR */
  JITTER_INSTRUCTION_PROLOG_(check-in-arity/n8/fR, check_min_marity__n8__fR, hot)
  { /* This block begins with definitions for check-in-arity/n8/fR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       69
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         check-in-arity/n8/fR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "check-in-arity"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "check-in-arity/n8/fR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME check_min_marity__n8__fR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity varies depending on whether we have fast labels. */
#ifdef JITTER_HAVE_PATCH_IN
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
#else
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
#endif // #ifdef JITTER_HAVE_PATCH_IN

  /* Define argument-access macros for check-in-arity/n8/fR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 8L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)

    /* The 1th argument is a "residual" fast label.  Define its
       _ARGF macro as the residual *index* (counting only fast labels, 0-based),
       so that at replication time we know what instruction address to patch in. */
#   define JITTER_ARGF1 0
    /* JITTER_ARG1 is intentionally not defined for a fast label. */

#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 8L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of check-in-arity/n8/fR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "check-in-arity/n8/fR"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for check-in-arity/n8/fR . */
  {
/* User-specified code, user code block part: beginning. */

#   ifndef JITTERLISP_UNSAFE
      /* Here we can assume that the top object is a closure, without checking:
         we either already performed a type check, or the compiler decided it
         wasn't necessary. */
      jitterlisp_object top = JITTER_TOP_MAINSTACK();
      struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(top);

      JITTER_BRANCH_FAST_IF_NOTEQUAL(c->in_arity, JITTER_ARGN0, JITTER_ARGF1);
#   endif // #ifndef JITTERLISP_UNSAFE
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for check-in-arity/n8/fR . */

  //fprintf (stderr, "..Executed instruction %s\n", "check-in-arity/n8/fR");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the check-in-arity/n8/fR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(check-in-arity/n8/fR, check_min_marity__n8__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for check-in-arity/n8/fR, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction check-in-arity/n9/fR */
  JITTER_INSTRUCTION_PROLOG_(check-in-arity/n9/fR, check_min_marity__n9__fR, hot)
  { /* This block begins with definitions for check-in-arity/n9/fR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       70
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         check-in-arity/n9/fR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "check-in-arity"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "check-in-arity/n9/fR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME check_min_marity__n9__fR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity varies depending on whether we have fast labels. */
#ifdef JITTER_HAVE_PATCH_IN
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
#else
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
#endif // #ifdef JITTER_HAVE_PATCH_IN

  /* Define argument-access macros for check-in-arity/n9/fR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 9L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)

    /* The 1th argument is a "residual" fast label.  Define its
       _ARGF macro as the residual *index* (counting only fast labels, 0-based),
       so that at replication time we know what instruction address to patch in. */
#   define JITTER_ARGF1 0
    /* JITTER_ARG1 is intentionally not defined for a fast label. */

#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 9L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of check-in-arity/n9/fR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "check-in-arity/n9/fR"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for check-in-arity/n9/fR . */
  {
/* User-specified code, user code block part: beginning. */

#   ifndef JITTERLISP_UNSAFE
      /* Here we can assume that the top object is a closure, without checking:
         we either already performed a type check, or the compiler decided it
         wasn't necessary. */
      jitterlisp_object top = JITTER_TOP_MAINSTACK();
      struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(top);

      JITTER_BRANCH_FAST_IF_NOTEQUAL(c->in_arity, JITTER_ARGN0, JITTER_ARGF1);
#   endif // #ifndef JITTERLISP_UNSAFE
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for check-in-arity/n9/fR . */

  //fprintf (stderr, "..Executed instruction %s\n", "check-in-arity/n9/fR");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the check-in-arity/n9/fR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(check-in-arity/n9/fR, check_min_marity__n9__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for check-in-arity/n9/fR, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction check-in-arity/n10/fR */
  JITTER_INSTRUCTION_PROLOG_(check-in-arity/n10/fR, check_min_marity__n10__fR, hot)
  { /* This block begins with definitions for check-in-arity/n10/fR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       71
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         check-in-arity/n10/fR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "check-in-arity"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "check-in-arity/n10/fR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME check_min_marity__n10__fR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity varies depending on whether we have fast labels. */
#ifdef JITTER_HAVE_PATCH_IN
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
#else
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
#endif // #ifdef JITTER_HAVE_PATCH_IN

  /* Define argument-access macros for check-in-arity/n10/fR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 10L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)

    /* The 1th argument is a "residual" fast label.  Define its
       _ARGF macro as the residual *index* (counting only fast labels, 0-based),
       so that at replication time we know what instruction address to patch in. */
#   define JITTER_ARGF1 0
    /* JITTER_ARG1 is intentionally not defined for a fast label. */

#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 10L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of check-in-arity/n10/fR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "check-in-arity/n10/fR"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for check-in-arity/n10/fR . */
  {
/* User-specified code, user code block part: beginning. */

#   ifndef JITTERLISP_UNSAFE
      /* Here we can assume that the top object is a closure, without checking:
         we either already performed a type check, or the compiler decided it
         wasn't necessary. */
      jitterlisp_object top = JITTER_TOP_MAINSTACK();
      struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(top);

      JITTER_BRANCH_FAST_IF_NOTEQUAL(c->in_arity, JITTER_ARGN0, JITTER_ARGF1);
#   endif // #ifndef JITTERLISP_UNSAFE
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for check-in-arity/n10/fR . */

  //fprintf (stderr, "..Executed instruction %s\n", "check-in-arity/n10/fR");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the check-in-arity/n10/fR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(check-in-arity/n10/fR, check_min_marity__n10__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for check-in-arity/n10/fR, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction check-in-arity/nR/fR */
  JITTER_INSTRUCTION_PROLOG_(check-in-arity/nR/fR, check_min_marity__nR__fR, cold)
  { /* This block begins with definitions for check-in-arity/nR/fR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       72
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         check-in-arity/nR/fR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "check-in-arity"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "check-in-arity/nR/fR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME check_min_marity__nR__fR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity varies depending on whether we have fast labels. */
#ifdef JITTER_HAVE_PATCH_IN
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
#else
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 2
#endif // #ifdef JITTER_HAVE_PATCH_IN

  /* Define argument-access macros for check-in-arity/nR/fR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a residual literal. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)

    /* The 1th argument is a "residual" fast label.  Define its
       _ARGF macro as the residual *index* (counting only fast labels, 0-based),
       so that at replication time we know what instruction address to patch in. */
#   define JITTER_ARGF1 0
    /* JITTER_ARG1 is intentionally not defined for a fast label. */

#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
    /* The 0th argument is a residual literal. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of check-in-arity/nR/fR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "check-in-arity/nR/fR"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for check-in-arity/nR/fR . */
  {
/* User-specified code, user code block part: beginning. */

#   ifndef JITTERLISP_UNSAFE
      /* Here we can assume that the top object is a closure, without checking:
         we either already performed a type check, or the compiler decided it
         wasn't necessary. */
      jitterlisp_object top = JITTER_TOP_MAINSTACK();
      struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(top);

      JITTER_BRANCH_FAST_IF_NOTEQUAL(c->in_arity, JITTER_ARGN0, JITTER_ARGF1);
#   endif // #ifndef JITTERLISP_UNSAFE
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for check-in-arity/nR/fR . */

  //fprintf (stderr, "..Executed instruction %s\n", "check-in-arity/nR/fR");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the check-in-arity/nR/fR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(check-in-arity/nR/fR, check_min_marity__nR__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for check-in-arity/nR/fR, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction check-in-arity--alt/n0/fR */
  JITTER_INSTRUCTION_PROLOG_(check-in-arity--alt/n0/fR, check_min_marity_m_malt__n0__fR, hot)
  { /* This block begins with definitions for check-in-arity--alt/n0/fR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       73
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         check-in-arity--alt/n0/fR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "check-in-arity--alt"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "check-in-arity--alt/n0/fR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME check_min_marity_m_malt__n0__fR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity varies depending on whether we have fast labels. */
#ifdef JITTER_HAVE_PATCH_IN
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
#else
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
#endif // #ifdef JITTER_HAVE_PATCH_IN

  /* Define argument-access macros for check-in-arity--alt/n0/fR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 0L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)

    /* The 1th argument is a "residual" fast label.  Define its
       _ARGF macro as the residual *index* (counting only fast labels, 0-based),
       so that at replication time we know what instruction address to patch in. */
#   define JITTER_ARGF1 0
    /* JITTER_ARG1 is intentionally not defined for a fast label. */

#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 0L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of check-in-arity--alt/n0/fR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "check-in-arity--alt/n0/fR"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for check-in-arity--alt/n0/fR . */
  {
/* User-specified code, user code block part: beginning. */

    // FIXME: this loops forever with no-threading (not with the other dispatches
    // including minimal threading) when the callee is compiled.  A Jitter bug.
    /* Here we can assume that the top object is a closure, without checking: we either
       already performed a type check, or the compiler decided it wasn't necessary. */
    jitterlisp_object top = JITTER_TOP_MAINSTACK();
    struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(top);

    /* FIXME: this is optimizable.  I should store the in-arity as a field, independently
       from the closure compiledness.  [Done] */
    if (JITTERLISP_IS_COMPILED_CLOSURE(top))
      {
        if (c->in_arity != JITTER_ARGN0)
          JITTER_BRANCH_FAST(JITTER_ARGF1);
      }
    else
      {
        /* The closure is interpreted.  Compute its in-arity.  We can assume that
           the formal list is well-formal, which is to say actually a proper list
           of distinct symbols. */
        struct jitterlisp_interpreted_closure *ic = & c->interpreted;
        jitterlisp_object rest = ic->formals;
        jitter_uint in_arity = 0;
        while (! JITTERLISP_IS_EMPTY_LIST(rest))
          {
            in_arity ++;
            rest = JITTERLISP_EXP_C_A_CDR(rest);
          }
        if (in_arity != JITTER_ARGN0)
          JITTER_BRANCH_FAST(JITTER_ARGF1);
      }
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for check-in-arity--alt/n0/fR . */

  //fprintf (stderr, "..Executed instruction %s\n", "check-in-arity--alt/n0/fR");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the check-in-arity--alt/n0/fR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(check-in-arity--alt/n0/fR, check_min_marity_m_malt__n0__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for check-in-arity--alt/n0/fR, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction check-in-arity--alt/n1/fR */
  JITTER_INSTRUCTION_PROLOG_(check-in-arity--alt/n1/fR, check_min_marity_m_malt__n1__fR, hot)
  { /* This block begins with definitions for check-in-arity--alt/n1/fR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       74
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         check-in-arity--alt/n1/fR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "check-in-arity--alt"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "check-in-arity--alt/n1/fR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME check_min_marity_m_malt__n1__fR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity varies depending on whether we have fast labels. */
#ifdef JITTER_HAVE_PATCH_IN
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
#else
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
#endif // #ifdef JITTER_HAVE_PATCH_IN

  /* Define argument-access macros for check-in-arity--alt/n1/fR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 1L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)

    /* The 1th argument is a "residual" fast label.  Define its
       _ARGF macro as the residual *index* (counting only fast labels, 0-based),
       so that at replication time we know what instruction address to patch in. */
#   define JITTER_ARGF1 0
    /* JITTER_ARG1 is intentionally not defined for a fast label. */

#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 1L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of check-in-arity--alt/n1/fR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "check-in-arity--alt/n1/fR"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for check-in-arity--alt/n1/fR . */
  {
/* User-specified code, user code block part: beginning. */

    // FIXME: this loops forever with no-threading (not with the other dispatches
    // including minimal threading) when the callee is compiled.  A Jitter bug.
    /* Here we can assume that the top object is a closure, without checking: we either
       already performed a type check, or the compiler decided it wasn't necessary. */
    jitterlisp_object top = JITTER_TOP_MAINSTACK();
    struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(top);

    /* FIXME: this is optimizable.  I should store the in-arity as a field, independently
       from the closure compiledness.  [Done] */
    if (JITTERLISP_IS_COMPILED_CLOSURE(top))
      {
        if (c->in_arity != JITTER_ARGN0)
          JITTER_BRANCH_FAST(JITTER_ARGF1);
      }
    else
      {
        /* The closure is interpreted.  Compute its in-arity.  We can assume that
           the formal list is well-formal, which is to say actually a proper list
           of distinct symbols. */
        struct jitterlisp_interpreted_closure *ic = & c->interpreted;
        jitterlisp_object rest = ic->formals;
        jitter_uint in_arity = 0;
        while (! JITTERLISP_IS_EMPTY_LIST(rest))
          {
            in_arity ++;
            rest = JITTERLISP_EXP_C_A_CDR(rest);
          }
        if (in_arity != JITTER_ARGN0)
          JITTER_BRANCH_FAST(JITTER_ARGF1);
      }
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for check-in-arity--alt/n1/fR . */

  //fprintf (stderr, "..Executed instruction %s\n", "check-in-arity--alt/n1/fR");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the check-in-arity--alt/n1/fR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(check-in-arity--alt/n1/fR, check_min_marity_m_malt__n1__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for check-in-arity--alt/n1/fR, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction check-in-arity--alt/n2/fR */
  JITTER_INSTRUCTION_PROLOG_(check-in-arity--alt/n2/fR, check_min_marity_m_malt__n2__fR, hot)
  { /* This block begins with definitions for check-in-arity--alt/n2/fR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       75
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         check-in-arity--alt/n2/fR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "check-in-arity--alt"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "check-in-arity--alt/n2/fR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME check_min_marity_m_malt__n2__fR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity varies depending on whether we have fast labels. */
#ifdef JITTER_HAVE_PATCH_IN
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
#else
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
#endif // #ifdef JITTER_HAVE_PATCH_IN

  /* Define argument-access macros for check-in-arity--alt/n2/fR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 2L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)

    /* The 1th argument is a "residual" fast label.  Define its
       _ARGF macro as the residual *index* (counting only fast labels, 0-based),
       so that at replication time we know what instruction address to patch in. */
#   define JITTER_ARGF1 0
    /* JITTER_ARG1 is intentionally not defined for a fast label. */

#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 2L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of check-in-arity--alt/n2/fR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "check-in-arity--alt/n2/fR"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for check-in-arity--alt/n2/fR . */
  {
/* User-specified code, user code block part: beginning. */

    // FIXME: this loops forever with no-threading (not with the other dispatches
    // including minimal threading) when the callee is compiled.  A Jitter bug.
    /* Here we can assume that the top object is a closure, without checking: we either
       already performed a type check, or the compiler decided it wasn't necessary. */
    jitterlisp_object top = JITTER_TOP_MAINSTACK();
    struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(top);

    /* FIXME: this is optimizable.  I should store the in-arity as a field, independently
       from the closure compiledness.  [Done] */
    if (JITTERLISP_IS_COMPILED_CLOSURE(top))
      {
        if (c->in_arity != JITTER_ARGN0)
          JITTER_BRANCH_FAST(JITTER_ARGF1);
      }
    else
      {
        /* The closure is interpreted.  Compute its in-arity.  We can assume that
           the formal list is well-formal, which is to say actually a proper list
           of distinct symbols. */
        struct jitterlisp_interpreted_closure *ic = & c->interpreted;
        jitterlisp_object rest = ic->formals;
        jitter_uint in_arity = 0;
        while (! JITTERLISP_IS_EMPTY_LIST(rest))
          {
            in_arity ++;
            rest = JITTERLISP_EXP_C_A_CDR(rest);
          }
        if (in_arity != JITTER_ARGN0)
          JITTER_BRANCH_FAST(JITTER_ARGF1);
      }
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for check-in-arity--alt/n2/fR . */

  //fprintf (stderr, "..Executed instruction %s\n", "check-in-arity--alt/n2/fR");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the check-in-arity--alt/n2/fR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(check-in-arity--alt/n2/fR, check_min_marity_m_malt__n2__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for check-in-arity--alt/n2/fR, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction check-in-arity--alt/n3/fR */
  JITTER_INSTRUCTION_PROLOG_(check-in-arity--alt/n3/fR, check_min_marity_m_malt__n3__fR, hot)
  { /* This block begins with definitions for check-in-arity--alt/n3/fR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       76
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         check-in-arity--alt/n3/fR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "check-in-arity--alt"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "check-in-arity--alt/n3/fR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME check_min_marity_m_malt__n3__fR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity varies depending on whether we have fast labels. */
#ifdef JITTER_HAVE_PATCH_IN
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
#else
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
#endif // #ifdef JITTER_HAVE_PATCH_IN

  /* Define argument-access macros for check-in-arity--alt/n3/fR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 3L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)

    /* The 1th argument is a "residual" fast label.  Define its
       _ARGF macro as the residual *index* (counting only fast labels, 0-based),
       so that at replication time we know what instruction address to patch in. */
#   define JITTER_ARGF1 0
    /* JITTER_ARG1 is intentionally not defined for a fast label. */

#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 3L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of check-in-arity--alt/n3/fR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "check-in-arity--alt/n3/fR"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for check-in-arity--alt/n3/fR . */
  {
/* User-specified code, user code block part: beginning. */

    // FIXME: this loops forever with no-threading (not with the other dispatches
    // including minimal threading) when the callee is compiled.  A Jitter bug.
    /* Here we can assume that the top object is a closure, without checking: we either
       already performed a type check, or the compiler decided it wasn't necessary. */
    jitterlisp_object top = JITTER_TOP_MAINSTACK();
    struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(top);

    /* FIXME: this is optimizable.  I should store the in-arity as a field, independently
       from the closure compiledness.  [Done] */
    if (JITTERLISP_IS_COMPILED_CLOSURE(top))
      {
        if (c->in_arity != JITTER_ARGN0)
          JITTER_BRANCH_FAST(JITTER_ARGF1);
      }
    else
      {
        /* The closure is interpreted.  Compute its in-arity.  We can assume that
           the formal list is well-formal, which is to say actually a proper list
           of distinct symbols. */
        struct jitterlisp_interpreted_closure *ic = & c->interpreted;
        jitterlisp_object rest = ic->formals;
        jitter_uint in_arity = 0;
        while (! JITTERLISP_IS_EMPTY_LIST(rest))
          {
            in_arity ++;
            rest = JITTERLISP_EXP_C_A_CDR(rest);
          }
        if (in_arity != JITTER_ARGN0)
          JITTER_BRANCH_FAST(JITTER_ARGF1);
      }
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for check-in-arity--alt/n3/fR . */

  //fprintf (stderr, "..Executed instruction %s\n", "check-in-arity--alt/n3/fR");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the check-in-arity--alt/n3/fR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(check-in-arity--alt/n3/fR, check_min_marity_m_malt__n3__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for check-in-arity--alt/n3/fR, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction check-in-arity--alt/n4/fR */
  JITTER_INSTRUCTION_PROLOG_(check-in-arity--alt/n4/fR, check_min_marity_m_malt__n4__fR, hot)
  { /* This block begins with definitions for check-in-arity--alt/n4/fR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       77
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         check-in-arity--alt/n4/fR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "check-in-arity--alt"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "check-in-arity--alt/n4/fR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME check_min_marity_m_malt__n4__fR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity varies depending on whether we have fast labels. */
#ifdef JITTER_HAVE_PATCH_IN
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
#else
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
#endif // #ifdef JITTER_HAVE_PATCH_IN

  /* Define argument-access macros for check-in-arity--alt/n4/fR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 4L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)

    /* The 1th argument is a "residual" fast label.  Define its
       _ARGF macro as the residual *index* (counting only fast labels, 0-based),
       so that at replication time we know what instruction address to patch in. */
#   define JITTER_ARGF1 0
    /* JITTER_ARG1 is intentionally not defined for a fast label. */

#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 4L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of check-in-arity--alt/n4/fR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "check-in-arity--alt/n4/fR"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for check-in-arity--alt/n4/fR . */
  {
/* User-specified code, user code block part: beginning. */

    // FIXME: this loops forever with no-threading (not with the other dispatches
    // including minimal threading) when the callee is compiled.  A Jitter bug.
    /* Here we can assume that the top object is a closure, without checking: we either
       already performed a type check, or the compiler decided it wasn't necessary. */
    jitterlisp_object top = JITTER_TOP_MAINSTACK();
    struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(top);

    /* FIXME: this is optimizable.  I should store the in-arity as a field, independently
       from the closure compiledness.  [Done] */
    if (JITTERLISP_IS_COMPILED_CLOSURE(top))
      {
        if (c->in_arity != JITTER_ARGN0)
          JITTER_BRANCH_FAST(JITTER_ARGF1);
      }
    else
      {
        /* The closure is interpreted.  Compute its in-arity.  We can assume that
           the formal list is well-formal, which is to say actually a proper list
           of distinct symbols. */
        struct jitterlisp_interpreted_closure *ic = & c->interpreted;
        jitterlisp_object rest = ic->formals;
        jitter_uint in_arity = 0;
        while (! JITTERLISP_IS_EMPTY_LIST(rest))
          {
            in_arity ++;
            rest = JITTERLISP_EXP_C_A_CDR(rest);
          }
        if (in_arity != JITTER_ARGN0)
          JITTER_BRANCH_FAST(JITTER_ARGF1);
      }
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for check-in-arity--alt/n4/fR . */

  //fprintf (stderr, "..Executed instruction %s\n", "check-in-arity--alt/n4/fR");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the check-in-arity--alt/n4/fR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(check-in-arity--alt/n4/fR, check_min_marity_m_malt__n4__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for check-in-arity--alt/n4/fR, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction check-in-arity--alt/n5/fR */
  JITTER_INSTRUCTION_PROLOG_(check-in-arity--alt/n5/fR, check_min_marity_m_malt__n5__fR, hot)
  { /* This block begins with definitions for check-in-arity--alt/n5/fR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       78
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         check-in-arity--alt/n5/fR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "check-in-arity--alt"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "check-in-arity--alt/n5/fR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME check_min_marity_m_malt__n5__fR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity varies depending on whether we have fast labels. */
#ifdef JITTER_HAVE_PATCH_IN
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
#else
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
#endif // #ifdef JITTER_HAVE_PATCH_IN

  /* Define argument-access macros for check-in-arity--alt/n5/fR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 5L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)

    /* The 1th argument is a "residual" fast label.  Define its
       _ARGF macro as the residual *index* (counting only fast labels, 0-based),
       so that at replication time we know what instruction address to patch in. */
#   define JITTER_ARGF1 0
    /* JITTER_ARG1 is intentionally not defined for a fast label. */

#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 5L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of check-in-arity--alt/n5/fR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "check-in-arity--alt/n5/fR"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for check-in-arity--alt/n5/fR . */
  {
/* User-specified code, user code block part: beginning. */

    // FIXME: this loops forever with no-threading (not with the other dispatches
    // including minimal threading) when the callee is compiled.  A Jitter bug.
    /* Here we can assume that the top object is a closure, without checking: we either
       already performed a type check, or the compiler decided it wasn't necessary. */
    jitterlisp_object top = JITTER_TOP_MAINSTACK();
    struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(top);

    /* FIXME: this is optimizable.  I should store the in-arity as a field, independently
       from the closure compiledness.  [Done] */
    if (JITTERLISP_IS_COMPILED_CLOSURE(top))
      {
        if (c->in_arity != JITTER_ARGN0)
          JITTER_BRANCH_FAST(JITTER_ARGF1);
      }
    else
      {
        /* The closure is interpreted.  Compute its in-arity.  We can assume that
           the formal list is well-formal, which is to say actually a proper list
           of distinct symbols. */
        struct jitterlisp_interpreted_closure *ic = & c->interpreted;
        jitterlisp_object rest = ic->formals;
        jitter_uint in_arity = 0;
        while (! JITTERLISP_IS_EMPTY_LIST(rest))
          {
            in_arity ++;
            rest = JITTERLISP_EXP_C_A_CDR(rest);
          }
        if (in_arity != JITTER_ARGN0)
          JITTER_BRANCH_FAST(JITTER_ARGF1);
      }
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for check-in-arity--alt/n5/fR . */

  //fprintf (stderr, "..Executed instruction %s\n", "check-in-arity--alt/n5/fR");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the check-in-arity--alt/n5/fR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(check-in-arity--alt/n5/fR, check_min_marity_m_malt__n5__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for check-in-arity--alt/n5/fR, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction check-in-arity--alt/n6/fR */
  JITTER_INSTRUCTION_PROLOG_(check-in-arity--alt/n6/fR, check_min_marity_m_malt__n6__fR, hot)
  { /* This block begins with definitions for check-in-arity--alt/n6/fR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       79
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         check-in-arity--alt/n6/fR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "check-in-arity--alt"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "check-in-arity--alt/n6/fR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME check_min_marity_m_malt__n6__fR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity varies depending on whether we have fast labels. */
#ifdef JITTER_HAVE_PATCH_IN
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
#else
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
#endif // #ifdef JITTER_HAVE_PATCH_IN

  /* Define argument-access macros for check-in-arity--alt/n6/fR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 6L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)

    /* The 1th argument is a "residual" fast label.  Define its
       _ARGF macro as the residual *index* (counting only fast labels, 0-based),
       so that at replication time we know what instruction address to patch in. */
#   define JITTER_ARGF1 0
    /* JITTER_ARG1 is intentionally not defined for a fast label. */

#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 6L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of check-in-arity--alt/n6/fR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "check-in-arity--alt/n6/fR"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for check-in-arity--alt/n6/fR . */
  {
/* User-specified code, user code block part: beginning. */

    // FIXME: this loops forever with no-threading (not with the other dispatches
    // including minimal threading) when the callee is compiled.  A Jitter bug.
    /* Here we can assume that the top object is a closure, without checking: we either
       already performed a type check, or the compiler decided it wasn't necessary. */
    jitterlisp_object top = JITTER_TOP_MAINSTACK();
    struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(top);

    /* FIXME: this is optimizable.  I should store the in-arity as a field, independently
       from the closure compiledness.  [Done] */
    if (JITTERLISP_IS_COMPILED_CLOSURE(top))
      {
        if (c->in_arity != JITTER_ARGN0)
          JITTER_BRANCH_FAST(JITTER_ARGF1);
      }
    else
      {
        /* The closure is interpreted.  Compute its in-arity.  We can assume that
           the formal list is well-formal, which is to say actually a proper list
           of distinct symbols. */
        struct jitterlisp_interpreted_closure *ic = & c->interpreted;
        jitterlisp_object rest = ic->formals;
        jitter_uint in_arity = 0;
        while (! JITTERLISP_IS_EMPTY_LIST(rest))
          {
            in_arity ++;
            rest = JITTERLISP_EXP_C_A_CDR(rest);
          }
        if (in_arity != JITTER_ARGN0)
          JITTER_BRANCH_FAST(JITTER_ARGF1);
      }
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for check-in-arity--alt/n6/fR . */

  //fprintf (stderr, "..Executed instruction %s\n", "check-in-arity--alt/n6/fR");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the check-in-arity--alt/n6/fR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(check-in-arity--alt/n6/fR, check_min_marity_m_malt__n6__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for check-in-arity--alt/n6/fR, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction check-in-arity--alt/n7/fR */
  JITTER_INSTRUCTION_PROLOG_(check-in-arity--alt/n7/fR, check_min_marity_m_malt__n7__fR, hot)
  { /* This block begins with definitions for check-in-arity--alt/n7/fR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       80
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         check-in-arity--alt/n7/fR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "check-in-arity--alt"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "check-in-arity--alt/n7/fR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME check_min_marity_m_malt__n7__fR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity varies depending on whether we have fast labels. */
#ifdef JITTER_HAVE_PATCH_IN
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
#else
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
#endif // #ifdef JITTER_HAVE_PATCH_IN

  /* Define argument-access macros for check-in-arity--alt/n7/fR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 7L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)

    /* The 1th argument is a "residual" fast label.  Define its
       _ARGF macro as the residual *index* (counting only fast labels, 0-based),
       so that at replication time we know what instruction address to patch in. */
#   define JITTER_ARGF1 0
    /* JITTER_ARG1 is intentionally not defined for a fast label. */

#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 7L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of check-in-arity--alt/n7/fR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "check-in-arity--alt/n7/fR"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for check-in-arity--alt/n7/fR . */
  {
/* User-specified code, user code block part: beginning. */

    // FIXME: this loops forever with no-threading (not with the other dispatches
    // including minimal threading) when the callee is compiled.  A Jitter bug.
    /* Here we can assume that the top object is a closure, without checking: we either
       already performed a type check, or the compiler decided it wasn't necessary. */
    jitterlisp_object top = JITTER_TOP_MAINSTACK();
    struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(top);

    /* FIXME: this is optimizable.  I should store the in-arity as a field, independently
       from the closure compiledness.  [Done] */
    if (JITTERLISP_IS_COMPILED_CLOSURE(top))
      {
        if (c->in_arity != JITTER_ARGN0)
          JITTER_BRANCH_FAST(JITTER_ARGF1);
      }
    else
      {
        /* The closure is interpreted.  Compute its in-arity.  We can assume that
           the formal list is well-formal, which is to say actually a proper list
           of distinct symbols. */
        struct jitterlisp_interpreted_closure *ic = & c->interpreted;
        jitterlisp_object rest = ic->formals;
        jitter_uint in_arity = 0;
        while (! JITTERLISP_IS_EMPTY_LIST(rest))
          {
            in_arity ++;
            rest = JITTERLISP_EXP_C_A_CDR(rest);
          }
        if (in_arity != JITTER_ARGN0)
          JITTER_BRANCH_FAST(JITTER_ARGF1);
      }
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for check-in-arity--alt/n7/fR . */

  //fprintf (stderr, "..Executed instruction %s\n", "check-in-arity--alt/n7/fR");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the check-in-arity--alt/n7/fR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(check-in-arity--alt/n7/fR, check_min_marity_m_malt__n7__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for check-in-arity--alt/n7/fR, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction check-in-arity--alt/n8/fR */
  JITTER_INSTRUCTION_PROLOG_(check-in-arity--alt/n8/fR, check_min_marity_m_malt__n8__fR, hot)
  { /* This block begins with definitions for check-in-arity--alt/n8/fR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       81
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         check-in-arity--alt/n8/fR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "check-in-arity--alt"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "check-in-arity--alt/n8/fR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME check_min_marity_m_malt__n8__fR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity varies depending on whether we have fast labels. */
#ifdef JITTER_HAVE_PATCH_IN
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
#else
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
#endif // #ifdef JITTER_HAVE_PATCH_IN

  /* Define argument-access macros for check-in-arity--alt/n8/fR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 8L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)

    /* The 1th argument is a "residual" fast label.  Define its
       _ARGF macro as the residual *index* (counting only fast labels, 0-based),
       so that at replication time we know what instruction address to patch in. */
#   define JITTER_ARGF1 0
    /* JITTER_ARG1 is intentionally not defined for a fast label. */

#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 8L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of check-in-arity--alt/n8/fR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "check-in-arity--alt/n8/fR"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for check-in-arity--alt/n8/fR . */
  {
/* User-specified code, user code block part: beginning. */

    // FIXME: this loops forever with no-threading (not with the other dispatches
    // including minimal threading) when the callee is compiled.  A Jitter bug.
    /* Here we can assume that the top object is a closure, without checking: we either
       already performed a type check, or the compiler decided it wasn't necessary. */
    jitterlisp_object top = JITTER_TOP_MAINSTACK();
    struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(top);

    /* FIXME: this is optimizable.  I should store the in-arity as a field, independently
       from the closure compiledness.  [Done] */
    if (JITTERLISP_IS_COMPILED_CLOSURE(top))
      {
        if (c->in_arity != JITTER_ARGN0)
          JITTER_BRANCH_FAST(JITTER_ARGF1);
      }
    else
      {
        /* The closure is interpreted.  Compute its in-arity.  We can assume that
           the formal list is well-formal, which is to say actually a proper list
           of distinct symbols. */
        struct jitterlisp_interpreted_closure *ic = & c->interpreted;
        jitterlisp_object rest = ic->formals;
        jitter_uint in_arity = 0;
        while (! JITTERLISP_IS_EMPTY_LIST(rest))
          {
            in_arity ++;
            rest = JITTERLISP_EXP_C_A_CDR(rest);
          }
        if (in_arity != JITTER_ARGN0)
          JITTER_BRANCH_FAST(JITTER_ARGF1);
      }
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for check-in-arity--alt/n8/fR . */

  //fprintf (stderr, "..Executed instruction %s\n", "check-in-arity--alt/n8/fR");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the check-in-arity--alt/n8/fR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(check-in-arity--alt/n8/fR, check_min_marity_m_malt__n8__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for check-in-arity--alt/n8/fR, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction check-in-arity--alt/n9/fR */
  JITTER_INSTRUCTION_PROLOG_(check-in-arity--alt/n9/fR, check_min_marity_m_malt__n9__fR, hot)
  { /* This block begins with definitions for check-in-arity--alt/n9/fR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       82
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         check-in-arity--alt/n9/fR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "check-in-arity--alt"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "check-in-arity--alt/n9/fR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME check_min_marity_m_malt__n9__fR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity varies depending on whether we have fast labels. */
#ifdef JITTER_HAVE_PATCH_IN
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
#else
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
#endif // #ifdef JITTER_HAVE_PATCH_IN

  /* Define argument-access macros for check-in-arity--alt/n9/fR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 9L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)

    /* The 1th argument is a "residual" fast label.  Define its
       _ARGF macro as the residual *index* (counting only fast labels, 0-based),
       so that at replication time we know what instruction address to patch in. */
#   define JITTER_ARGF1 0
    /* JITTER_ARG1 is intentionally not defined for a fast label. */

#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 9L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of check-in-arity--alt/n9/fR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "check-in-arity--alt/n9/fR"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for check-in-arity--alt/n9/fR . */
  {
/* User-specified code, user code block part: beginning. */

    // FIXME: this loops forever with no-threading (not with the other dispatches
    // including minimal threading) when the callee is compiled.  A Jitter bug.
    /* Here we can assume that the top object is a closure, without checking: we either
       already performed a type check, or the compiler decided it wasn't necessary. */
    jitterlisp_object top = JITTER_TOP_MAINSTACK();
    struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(top);

    /* FIXME: this is optimizable.  I should store the in-arity as a field, independently
       from the closure compiledness.  [Done] */
    if (JITTERLISP_IS_COMPILED_CLOSURE(top))
      {
        if (c->in_arity != JITTER_ARGN0)
          JITTER_BRANCH_FAST(JITTER_ARGF1);
      }
    else
      {
        /* The closure is interpreted.  Compute its in-arity.  We can assume that
           the formal list is well-formal, which is to say actually a proper list
           of distinct symbols. */
        struct jitterlisp_interpreted_closure *ic = & c->interpreted;
        jitterlisp_object rest = ic->formals;
        jitter_uint in_arity = 0;
        while (! JITTERLISP_IS_EMPTY_LIST(rest))
          {
            in_arity ++;
            rest = JITTERLISP_EXP_C_A_CDR(rest);
          }
        if (in_arity != JITTER_ARGN0)
          JITTER_BRANCH_FAST(JITTER_ARGF1);
      }
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for check-in-arity--alt/n9/fR . */

  //fprintf (stderr, "..Executed instruction %s\n", "check-in-arity--alt/n9/fR");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the check-in-arity--alt/n9/fR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(check-in-arity--alt/n9/fR, check_min_marity_m_malt__n9__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for check-in-arity--alt/n9/fR, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction check-in-arity--alt/n10/fR */
  JITTER_INSTRUCTION_PROLOG_(check-in-arity--alt/n10/fR, check_min_marity_m_malt__n10__fR, hot)
  { /* This block begins with definitions for check-in-arity--alt/n10/fR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       83
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         check-in-arity--alt/n10/fR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "check-in-arity--alt"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "check-in-arity--alt/n10/fR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME check_min_marity_m_malt__n10__fR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity varies depending on whether we have fast labels. */
#ifdef JITTER_HAVE_PATCH_IN
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
#else
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
#endif // #ifdef JITTER_HAVE_PATCH_IN

  /* Define argument-access macros for check-in-arity--alt/n10/fR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 10L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)

    /* The 1th argument is a "residual" fast label.  Define its
       _ARGF macro as the residual *index* (counting only fast labels, 0-based),
       so that at replication time we know what instruction address to patch in. */
#   define JITTER_ARGF1 0
    /* JITTER_ARG1 is intentionally not defined for a fast label. */

#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 10L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of check-in-arity--alt/n10/fR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "check-in-arity--alt/n10/fR"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for check-in-arity--alt/n10/fR . */
  {
/* User-specified code, user code block part: beginning. */

    // FIXME: this loops forever with no-threading (not with the other dispatches
    // including minimal threading) when the callee is compiled.  A Jitter bug.
    /* Here we can assume that the top object is a closure, without checking: we either
       already performed a type check, or the compiler decided it wasn't necessary. */
    jitterlisp_object top = JITTER_TOP_MAINSTACK();
    struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(top);

    /* FIXME: this is optimizable.  I should store the in-arity as a field, independently
       from the closure compiledness.  [Done] */
    if (JITTERLISP_IS_COMPILED_CLOSURE(top))
      {
        if (c->in_arity != JITTER_ARGN0)
          JITTER_BRANCH_FAST(JITTER_ARGF1);
      }
    else
      {
        /* The closure is interpreted.  Compute its in-arity.  We can assume that
           the formal list is well-formal, which is to say actually a proper list
           of distinct symbols. */
        struct jitterlisp_interpreted_closure *ic = & c->interpreted;
        jitterlisp_object rest = ic->formals;
        jitter_uint in_arity = 0;
        while (! JITTERLISP_IS_EMPTY_LIST(rest))
          {
            in_arity ++;
            rest = JITTERLISP_EXP_C_A_CDR(rest);
          }
        if (in_arity != JITTER_ARGN0)
          JITTER_BRANCH_FAST(JITTER_ARGF1);
      }
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for check-in-arity--alt/n10/fR . */

  //fprintf (stderr, "..Executed instruction %s\n", "check-in-arity--alt/n10/fR");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the check-in-arity--alt/n10/fR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(check-in-arity--alt/n10/fR, check_min_marity_m_malt__n10__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for check-in-arity--alt/n10/fR, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction check-in-arity--alt/nR/fR */
  JITTER_INSTRUCTION_PROLOG_(check-in-arity--alt/nR/fR, check_min_marity_m_malt__nR__fR, cold)
  { /* This block begins with definitions for check-in-arity--alt/nR/fR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       84
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         check-in-arity--alt/nR/fR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "check-in-arity--alt"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "check-in-arity--alt/nR/fR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME check_min_marity_m_malt__nR__fR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity varies depending on whether we have fast labels. */
#ifdef JITTER_HAVE_PATCH_IN
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
#else
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 2
#endif // #ifdef JITTER_HAVE_PATCH_IN

  /* Define argument-access macros for check-in-arity--alt/nR/fR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a residual literal. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)

    /* The 1th argument is a "residual" fast label.  Define its
       _ARGF macro as the residual *index* (counting only fast labels, 0-based),
       so that at replication time we know what instruction address to patch in. */
#   define JITTER_ARGF1 0
    /* JITTER_ARG1 is intentionally not defined for a fast label. */

#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
    /* The 0th argument is a residual literal. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of check-in-arity--alt/nR/fR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "check-in-arity--alt/nR/fR"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for check-in-arity--alt/nR/fR . */
  {
/* User-specified code, user code block part: beginning. */

    // FIXME: this loops forever with no-threading (not with the other dispatches
    // including minimal threading) when the callee is compiled.  A Jitter bug.
    /* Here we can assume that the top object is a closure, without checking: we either
       already performed a type check, or the compiler decided it wasn't necessary. */
    jitterlisp_object top = JITTER_TOP_MAINSTACK();
    struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(top);

    /* FIXME: this is optimizable.  I should store the in-arity as a field, independently
       from the closure compiledness.  [Done] */
    if (JITTERLISP_IS_COMPILED_CLOSURE(top))
      {
        if (c->in_arity != JITTER_ARGN0)
          JITTER_BRANCH_FAST(JITTER_ARGF1);
      }
    else
      {
        /* The closure is interpreted.  Compute its in-arity.  We can assume that
           the formal list is well-formal, which is to say actually a proper list
           of distinct symbols. */
        struct jitterlisp_interpreted_closure *ic = & c->interpreted;
        jitterlisp_object rest = ic->formals;
        jitter_uint in_arity = 0;
        while (! JITTERLISP_IS_EMPTY_LIST(rest))
          {
            in_arity ++;
            rest = JITTERLISP_EXP_C_A_CDR(rest);
          }
        if (in_arity != JITTER_ARGN0)
          JITTER_BRANCH_FAST(JITTER_ARGF1);
      }
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for check-in-arity--alt/nR/fR . */

  //fprintf (stderr, "..Executed instruction %s\n", "check-in-arity--alt/nR/fR");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the check-in-arity--alt/nR/fR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(check-in-arity--alt/nR/fR, check_min_marity_m_malt__nR__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for check-in-arity--alt/nR/fR, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction copy-from-literal/nR */
  JITTER_INSTRUCTION_PROLOG_(copy-from-literal/nR, copy_mfrom_mliteral__nR, cold)
  { /* This block begins with definitions for copy-from-literal/nR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       85
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         copy-from-literal/nR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "copy-from-literal"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "copy-from-literal/nR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME copy_mfrom_mliteral__nR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is not branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is not branching: undefine branch
       macros so that they cannot be used by mistake. */
/* Locally poison JITTER_COMPUTED_GOTO . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_COMPUTED_GOTO")
# undef JITTER_COMPUTED_GOTO
# define JITTER_COMPUTED_GOTO JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_COMPUTED_GOTO, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_COMPUTED_GOTO
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_COMPUTED_GOTO . */

/* Locally poison JITTER_BRANCH . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_BRANCH")
# undef JITTER_BRANCH
# define JITTER_BRANCH JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_BRANCH, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_BRANCH
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_BRANCH . */

/* Locally poison JITTER_EXIT . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_EXIT")
# undef JITTER_EXIT
# define JITTER_EXIT JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_EXIT, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_EXIT
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_EXIT . */

  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1

    /* The 0th argument is a residual literal. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0


#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of copy-from-literal/nR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "copy-from-literal/nR"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for copy-from-literal/nR . */
  {
/* User-specified code, user code block part: beginning. */

    JITTER_TOP_MAINSTACK() = JITTER_ARGN0;
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for copy-from-literal/nR . */

  //fprintf (stderr, "..Executed instruction %s\n", "copy-from-literal/nR");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the copy-from-literal/nR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_EXIT")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_BRANCH")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_COMPUTED_GOTO")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(copy-from-literal/nR, copy_mfrom_mliteral__nR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for copy-from-literal/nR, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction copy-from-register/%rR */
  JITTER_INSTRUCTION_PROLOG_(copy-from-register/%rR, copy_mfrom_mregister___rrR, cold)
  { /* This block begins with definitions for copy-from-register/%rR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       86
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         copy-from-register/%rR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "copy-from-register"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "copy-from-register/%rR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME copy_mfrom_mregister___rrR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is not branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is not branching: undefine branch
       macros so that they cannot be used by mistake. */
/* Locally poison JITTER_COMPUTED_GOTO . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_COMPUTED_GOTO")
# undef JITTER_COMPUTED_GOTO
# define JITTER_COMPUTED_GOTO JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_COMPUTED_GOTO, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_COMPUTED_GOTO
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_COMPUTED_GOTO . */

/* Locally poison JITTER_BRANCH . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_BRANCH")
# undef JITTER_BRANCH
# define JITTER_BRANCH JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_BRANCH, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_BRANCH
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_BRANCH . */

/* Locally poison JITTER_EXIT . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_EXIT")
# undef JITTER_EXIT
# define JITTER_EXIT JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_EXIT, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_EXIT
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_EXIT . */

  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1

    /* The 0th argument is a slow (therefore residual, passed as an offset)
        register. */
  /* Define a macro expanding to the slow register offset. */
#if defined(JITTER_DISPATCH_NO_THREADING)
# define JITTER_SLOW_REGISTER_OFFSET0 (JITTER_RESIDUAL_ARGUMENT_0.fixnum)
#elif defined (JITTER_DISPATCH_MINIMAL_THREADING)
# define JITTER_SLOW_REGISTER_OFFSET0 ((((union jitter_word*)jitter_ip)[0]).fixnum)
#else
# define JITTER_SLOW_REGISTER_OFFSET0 ((((union jitter_word*)jitter_ip)[1]).fixnum)
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
  /* Define a macro expanding to an l-value for the VM register content. */
#   define JITTER_ARG0  JITTER_SLOW_REGISTER_FROM_OFFSET(r, JITTER_SLOW_REGISTER_OFFSET0)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0


#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of copy-from-register/%rR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "copy-from-register/%rR"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for copy-from-register/%rR . */
  {
/* User-specified code, user code block part: beginning. */

    JITTER_TOP_MAINSTACK() = JITTER_ARG0;
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for copy-from-register/%rR . */

  //fprintf (stderr, "..Executed instruction %s\n", "copy-from-register/%rR");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the copy-from-register/%rR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_EXIT")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_BRANCH")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_COMPUTED_GOTO")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(copy-from-register/%rR, copy_mfrom_mregister___rrR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for copy-from-register/%rR, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction copy-to-register/%rR */
  JITTER_INSTRUCTION_PROLOG_(copy-to-register/%rR, copy_mto_mregister___rrR, cold)
  { /* This block begins with definitions for copy-to-register/%rR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       87
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         copy-to-register/%rR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "copy-to-register"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "copy-to-register/%rR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME copy_mto_mregister___rrR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is not branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is not branching: undefine branch
       macros so that they cannot be used by mistake. */
/* Locally poison JITTER_COMPUTED_GOTO . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_COMPUTED_GOTO")
# undef JITTER_COMPUTED_GOTO
# define JITTER_COMPUTED_GOTO JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_COMPUTED_GOTO, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_COMPUTED_GOTO
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_COMPUTED_GOTO . */

/* Locally poison JITTER_BRANCH . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_BRANCH")
# undef JITTER_BRANCH
# define JITTER_BRANCH JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_BRANCH, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_BRANCH
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_BRANCH . */

/* Locally poison JITTER_EXIT . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_EXIT")
# undef JITTER_EXIT
# define JITTER_EXIT JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_EXIT, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_EXIT
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_EXIT . */

  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1

    /* The 0th argument is a slow (therefore residual, passed as an offset)
        register. */
  /* Define a macro expanding to the slow register offset. */
#if defined(JITTER_DISPATCH_NO_THREADING)
# define JITTER_SLOW_REGISTER_OFFSET0 (JITTER_RESIDUAL_ARGUMENT_0.fixnum)
#elif defined (JITTER_DISPATCH_MINIMAL_THREADING)
# define JITTER_SLOW_REGISTER_OFFSET0 ((((union jitter_word*)jitter_ip)[0]).fixnum)
#else
# define JITTER_SLOW_REGISTER_OFFSET0 ((((union jitter_word*)jitter_ip)[1]).fixnum)
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
  /* Define a macro expanding to an l-value for the VM register content. */
#   define JITTER_ARG0  JITTER_SLOW_REGISTER_FROM_OFFSET(r, JITTER_SLOW_REGISTER_OFFSET0)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0


#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of copy-to-register/%rR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "copy-to-register/%rR"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for copy-to-register/%rR . */
  {
/* User-specified code, user code block part: beginning. */

    JITTER_ARG0 = JITTER_TOP_MAINSTACK();
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for copy-to-register/%rR . */

  //fprintf (stderr, "..Executed instruction %s\n", "copy-to-register/%rR");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the copy-to-register/%rR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_EXIT")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_BRANCH")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_COMPUTED_GOTO")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(copy-to-register/%rR, copy_mto_mregister___rrR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for copy-to-register/%rR, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction drop */
  JITTER_INSTRUCTION_PROLOG_(drop, drop, hot)
  { /* This block begins with definitions for drop . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       88
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         drop
#   define JITTER_INSTRUCTION_NAME_AS_STRING "drop"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "drop"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME drop

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is not branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is not branching: undefine branch
       macros so that they cannot be used by mistake. */
/* Locally poison JITTER_COMPUTED_GOTO . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_COMPUTED_GOTO")
# undef JITTER_COMPUTED_GOTO
# define JITTER_COMPUTED_GOTO JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_COMPUTED_GOTO, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_COMPUTED_GOTO
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_COMPUTED_GOTO . */

/* Locally poison JITTER_BRANCH . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_BRANCH")
# undef JITTER_BRANCH
# define JITTER_BRANCH JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_BRANCH, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_BRANCH
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_BRANCH . */

/* Locally poison JITTER_EXIT . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_EXIT")
# undef JITTER_EXIT
# define JITTER_EXIT JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_EXIT, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_EXIT
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_EXIT . */

  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0


#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of drop ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "drop"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for drop . */
  {
/* User-specified code, user code block part: beginning. */

    JITTER_DROP_MAINSTACK();
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for drop . */

  //fprintf (stderr, "..Executed instruction %s\n", "drop");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the drop argument macros so they can't be used
       by mistake in the instruction body coming next. */

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_EXIT")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_BRANCH")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_COMPUTED_GOTO")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(drop, drop, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for drop, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction drop-nip */
  JITTER_INSTRUCTION_PROLOG_(drop-nip, drop_mnip, hot)
  { /* This block begins with definitions for drop-nip . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       89
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         drop-nip
#   define JITTER_INSTRUCTION_NAME_AS_STRING "drop-nip"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "drop-nip"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME drop_mnip

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is not branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is not branching: undefine branch
       macros so that they cannot be used by mistake. */
/* Locally poison JITTER_COMPUTED_GOTO . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_COMPUTED_GOTO")
# undef JITTER_COMPUTED_GOTO
# define JITTER_COMPUTED_GOTO JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_COMPUTED_GOTO, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_COMPUTED_GOTO
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_COMPUTED_GOTO . */

/* Locally poison JITTER_BRANCH . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_BRANCH")
# undef JITTER_BRANCH
# define JITTER_BRANCH JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_BRANCH, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_BRANCH
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_BRANCH . */

/* Locally poison JITTER_EXIT . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_EXIT")
# undef JITTER_EXIT
# define JITTER_EXIT JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_EXIT, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_EXIT
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_EXIT . */

  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0


#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of drop-nip ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "drop-nip"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for drop-nip . */
  {
/* User-specified code, user code block part: beginning. */

    JITTER_DROP_MAINSTACK();
    JITTER_NIP_MAINSTACK();
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for drop-nip . */

  //fprintf (stderr, "..Executed instruction %s\n", "drop-nip");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the drop-nip argument macros so they can't be used
       by mistake in the instruction body coming next. */

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_EXIT")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_BRANCH")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_COMPUTED_GOTO")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(drop-nip, drop_mnip, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for drop-nip, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction dup */
  JITTER_INSTRUCTION_PROLOG_(dup, dup, hot)
  { /* This block begins with definitions for dup . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       90
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         dup
#   define JITTER_INSTRUCTION_NAME_AS_STRING "dup"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "dup"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME dup

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is not branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is not branching: undefine branch
       macros so that they cannot be used by mistake. */
/* Locally poison JITTER_COMPUTED_GOTO . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_COMPUTED_GOTO")
# undef JITTER_COMPUTED_GOTO
# define JITTER_COMPUTED_GOTO JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_COMPUTED_GOTO, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_COMPUTED_GOTO
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_COMPUTED_GOTO . */

/* Locally poison JITTER_BRANCH . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_BRANCH")
# undef JITTER_BRANCH
# define JITTER_BRANCH JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_BRANCH, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_BRANCH
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_BRANCH . */

/* Locally poison JITTER_EXIT . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_EXIT")
# undef JITTER_EXIT
# define JITTER_EXIT JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_EXIT, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_EXIT
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_EXIT . */

  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0


#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of dup ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "dup"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for dup . */
  {
/* User-specified code, user code block part: beginning. */

    JITTER_DUP_MAINSTACK();
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for dup . */

  //fprintf (stderr, "..Executed instruction %s\n", "dup");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the dup argument macros so they can't be used
       by mistake in the instruction body coming next. */

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_EXIT")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_BRANCH")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_COMPUTED_GOTO")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(dup, dup, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for dup, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction exitvm */
  JITTER_INSTRUCTION_PROLOG_(exitvm, exitvm, cold)
  { /* This block begins with definitions for exitvm . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       91
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         exitvm
#   define JITTER_INSTRUCTION_NAME_AS_STRING "exitvm"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "exitvm"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME exitvm

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0


#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of exitvm ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "exitvm"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for exitvm . */
  {
/* User-specified code, user code block part: beginning. */
JITTER_EXIT();
/* User-specified code, user code block part: end */

  }
    /* End of the user code for exitvm . */

  //fprintf (stderr, "..Executed instruction %s\n", "exitvm");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the exitvm argument macros so they can't be used
       by mistake in the instruction body coming next. */

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(exitvm, exitvm, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for exitvm, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction fail/retR */
  JITTER_INSTRUCTION_PROLOG_(fail/retR, fail__retR, cold)
  { /* This block begins with definitions for fail/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       92
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         fail/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "fail"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "fail/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME fail__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is non-relocatable.
       Its 0-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is not branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is non-relocatable.
       Its 0-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is not branching: undefine branch
       macros so that they cannot be used by mistake. */
/* Locally poison JITTER_COMPUTED_GOTO . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_COMPUTED_GOTO")
# undef JITTER_COMPUTED_GOTO
# define JITTER_COMPUTED_GOTO JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_COMPUTED_GOTO, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_COMPUTED_GOTO
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_COMPUTED_GOTO . */

/* Locally poison JITTER_BRANCH . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_BRANCH")
# undef JITTER_BRANCH
# define JITTER_BRANCH JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_BRANCH, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_BRANCH
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_BRANCH . */

/* Locally poison JITTER_EXIT . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_EXIT")
# undef JITTER_EXIT
# define JITTER_EXIT JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_EXIT, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_EXIT
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_EXIT . */

  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1

    /* The 0th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0


#ifdef JITTER_REPLICATE
/* When jumping to the non-relocatable part it is important not
   to use a fallback version of JITTER_COMPUTED_GOTO, in order to
   prevent GCC from tail-merging. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
    /* Jump to non-relocatable code. */
    JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);

    /* Here the residual arity is given as zero: it's too late to
       skip residuals, since we've already jumped and this code is
       unreachable.  The instruction pointer, if any, is advanced
       in the non-relocatable code. */
    JITTER_INSTRUCTION_EPILOG_(fail/retR, fail__retR, 0)

    /* Relocated code will jump to this label in non-relocated code. */
  JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
    JITTER_COMMENT_IN_ASM_("fail/retR non-relocatable code");
#endif // #ifdef JITTER_REPLICATE
#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of fail/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  no. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "fail/retR"); fflush (stderr);
  //fprintf (stderr, "Executing non-relocatable instruction %s with JITTER_SPECIALIZED_INSTRUCTION_WORD_NO=%i..\n", "fail/retR", (int) JITTER_SPECIALIZED_INSTRUCTION_WORD_NO); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for fail/retR . */
  {
/* User-specified code, user code block part: beginning. */

    jitterlisp_fail_from_vm ();
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for fail/retR . */

  //fprintf (stderr, "..Executed instruction %s\n", "fail/retR");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
#ifdef JITTER_REPLICATE
  {
    /* Advance the instruction pointer, if any, to skip every
       residual but the last; branch back to replicated
       code. */
    const void *_jitter_back_to_replicated_code_pointer =
      JITTER_ARGP0;
    JITTER_SKIP_RESIDUALS_;
    goto * _jitter_back_to_replicated_code_pointer;
  }
#endif // #ifdef JITTER_REPLICATE

    /* Undefine the fail/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#ifndef JITTER_REPLICATE
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_EXIT")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_BRANCH")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_COMPUTED_GOTO")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(fail/retR, fail__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#endif // #ifndef JITTER_REPLICATE
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for fail/retR, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction gc-if-needed/fR */
  JITTER_INSTRUCTION_PROLOG_(gc-if-needed/fR, gc_mif_mneeded__fR, hot)
  { /* This block begins with definitions for gc-if-needed/fR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       93
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         gc-if-needed/fR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "gc-if-needed"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "gc-if-needed/fR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME gc_mif_mneeded__fR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity varies depending on whether we have fast labels. */
#ifdef JITTER_HAVE_PATCH_IN
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
#else
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
#endif // #ifdef JITTER_HAVE_PATCH_IN

  /* Define argument-access macros for gc-if-needed/fR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a "residual" fast label.  Define its
       _ARGF macro as the residual *index* (counting only fast labels, 0-based),
       so that at replication time we know what instruction address to patch in. */
#   define JITTER_ARGF0 0
    /* JITTER_ARG0 is intentionally not defined for a fast label. */

#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of gc-if-needed/fR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "gc-if-needed/fR"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for gc-if-needed/fR . */
  {
/* User-specified code, user code block part: beginning. */

#ifdef JITTER_GC_STUB
    /* FIXME: I might want to merge this, along with the body of other
       instructions, into a macro.  This may still be factored in a different
       way, but the idea looks correct and promising. */
    /* Branch to the slow path of the allocation, which includes a minor GC,
       in case the allocation pointer is now out of the nursery.  Do nothing
       otherwise.
       Rationale: separating branches from instructions having effect on the VM
       state prevents defective instructions; even if I have reason to believe
       that this particular state effect (unconditionally incrementing a runtime
       field) is not problematic with respect to defects, I will need to seriously
       stress the system after defect replacement is really implemented. */
    JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
       (JITTERLISPVM_STATE_RUNTIME_FIELD (allocation_next),
        JITTERLISPVM_STATE_RUNTIME_FIELD (allocation_limit),
        JITTER_ARGF0);
#else
    /* Nothing to do.  With the ordinary non-stub heap all the actual
       memory allocation happens in primitive-cons-special. */
#endif //#ifdef JITTER_GC_STUB
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for gc-if-needed/fR . */

  //fprintf (stderr, "..Executed instruction %s\n", "gc-if-needed/fR");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the gc-if-needed/fR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(gc-if-needed/fR, gc_mif_mneeded__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for gc-if-needed/fR, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction heap-allocate/n4 */
  JITTER_INSTRUCTION_PROLOG_(heap-allocate/n4, heap_mallocate__n4, hot)
  { /* This block begins with definitions for heap-allocate/n4 . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       94
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         heap-allocate/n4
#   define JITTER_INSTRUCTION_NAME_AS_STRING "heap-allocate"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "heap-allocate/n4"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME heap_mallocate__n4

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is not branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is not branching: undefine branch
       macros so that they cannot be used by mistake. */
/* Locally poison JITTER_COMPUTED_GOTO . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_COMPUTED_GOTO")
# undef JITTER_COMPUTED_GOTO
# define JITTER_COMPUTED_GOTO JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_COMPUTED_GOTO, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_COMPUTED_GOTO
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_COMPUTED_GOTO . */

/* Locally poison JITTER_BRANCH . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_BRANCH")
# undef JITTER_BRANCH
# define JITTER_BRANCH JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_BRANCH, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_BRANCH
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_BRANCH . */

/* Locally poison JITTER_EXIT . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_EXIT")
# undef JITTER_EXIT
# define JITTER_EXIT JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_EXIT, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_EXIT
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_EXIT . */

  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0

    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 4L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0


#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of heap-allocate/n4 ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "heap-allocate/n4"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for heap-allocate/n4 . */
  {
/* User-specified code, user code block part: beginning. */

#ifdef JITTER_GC_STUB
    /* FIXME: I might want to merge this, along with the body of other
       instructions, into a macro.  This may still be factored in a different
       way, but the idea looks correct and promising. */
    /* Bump the allocation pointer, unconditionally.  Another instruction
       will check if it went out of the nursery. */
    const size_t allocation_size = JITTER_ARGN0;
    JITTERLISPVM_STATE_RUNTIME_FIELD (allocation_next) += allocation_size;
#else
    /* Nothing to do.  With the ordinary non-stub heap all the actual
       memory allocation happens in primitive-cons-special. */
#endif //#ifdef JITTER_GC_STUB
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for heap-allocate/n4 . */

  //fprintf (stderr, "..Executed instruction %s\n", "heap-allocate/n4");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the heap-allocate/n4 argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_EXIT")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_BRANCH")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_COMPUTED_GOTO")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(heap-allocate/n4, heap_mallocate__n4, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for heap-allocate/n4, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction heap-allocate/n8 */
  JITTER_INSTRUCTION_PROLOG_(heap-allocate/n8, heap_mallocate__n8, hot)
  { /* This block begins with definitions for heap-allocate/n8 . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       95
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         heap-allocate/n8
#   define JITTER_INSTRUCTION_NAME_AS_STRING "heap-allocate"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "heap-allocate/n8"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME heap_mallocate__n8

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is not branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is not branching: undefine branch
       macros so that they cannot be used by mistake. */
/* Locally poison JITTER_COMPUTED_GOTO . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_COMPUTED_GOTO")
# undef JITTER_COMPUTED_GOTO
# define JITTER_COMPUTED_GOTO JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_COMPUTED_GOTO, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_COMPUTED_GOTO
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_COMPUTED_GOTO . */

/* Locally poison JITTER_BRANCH . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_BRANCH")
# undef JITTER_BRANCH
# define JITTER_BRANCH JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_BRANCH, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_BRANCH
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_BRANCH . */

/* Locally poison JITTER_EXIT . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_EXIT")
# undef JITTER_EXIT
# define JITTER_EXIT JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_EXIT, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_EXIT
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_EXIT . */

  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0

    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 8L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0


#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of heap-allocate/n8 ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "heap-allocate/n8"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for heap-allocate/n8 . */
  {
/* User-specified code, user code block part: beginning. */

#ifdef JITTER_GC_STUB
    /* FIXME: I might want to merge this, along with the body of other
       instructions, into a macro.  This may still be factored in a different
       way, but the idea looks correct and promising. */
    /* Bump the allocation pointer, unconditionally.  Another instruction
       will check if it went out of the nursery. */
    const size_t allocation_size = JITTER_ARGN0;
    JITTERLISPVM_STATE_RUNTIME_FIELD (allocation_next) += allocation_size;
#else
    /* Nothing to do.  With the ordinary non-stub heap all the actual
       memory allocation happens in primitive-cons-special. */
#endif //#ifdef JITTER_GC_STUB
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for heap-allocate/n8 . */

  //fprintf (stderr, "..Executed instruction %s\n", "heap-allocate/n8");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the heap-allocate/n8 argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_EXIT")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_BRANCH")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_COMPUTED_GOTO")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(heap-allocate/n8, heap_mallocate__n8, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for heap-allocate/n8, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction heap-allocate/n12 */
  JITTER_INSTRUCTION_PROLOG_(heap-allocate/n12, heap_mallocate__n12, hot)
  { /* This block begins with definitions for heap-allocate/n12 . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       96
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         heap-allocate/n12
#   define JITTER_INSTRUCTION_NAME_AS_STRING "heap-allocate"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "heap-allocate/n12"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME heap_mallocate__n12

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is not branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is not branching: undefine branch
       macros so that they cannot be used by mistake. */
/* Locally poison JITTER_COMPUTED_GOTO . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_COMPUTED_GOTO")
# undef JITTER_COMPUTED_GOTO
# define JITTER_COMPUTED_GOTO JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_COMPUTED_GOTO, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_COMPUTED_GOTO
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_COMPUTED_GOTO . */

/* Locally poison JITTER_BRANCH . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_BRANCH")
# undef JITTER_BRANCH
# define JITTER_BRANCH JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_BRANCH, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_BRANCH
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_BRANCH . */

/* Locally poison JITTER_EXIT . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_EXIT")
# undef JITTER_EXIT
# define JITTER_EXIT JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_EXIT, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_EXIT
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_EXIT . */

  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0

    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 12L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0


#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of heap-allocate/n12 ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "heap-allocate/n12"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for heap-allocate/n12 . */
  {
/* User-specified code, user code block part: beginning. */

#ifdef JITTER_GC_STUB
    /* FIXME: I might want to merge this, along with the body of other
       instructions, into a macro.  This may still be factored in a different
       way, but the idea looks correct and promising. */
    /* Bump the allocation pointer, unconditionally.  Another instruction
       will check if it went out of the nursery. */
    const size_t allocation_size = JITTER_ARGN0;
    JITTERLISPVM_STATE_RUNTIME_FIELD (allocation_next) += allocation_size;
#else
    /* Nothing to do.  With the ordinary non-stub heap all the actual
       memory allocation happens in primitive-cons-special. */
#endif //#ifdef JITTER_GC_STUB
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for heap-allocate/n12 . */

  //fprintf (stderr, "..Executed instruction %s\n", "heap-allocate/n12");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the heap-allocate/n12 argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_EXIT")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_BRANCH")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_COMPUTED_GOTO")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(heap-allocate/n12, heap_mallocate__n12, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for heap-allocate/n12, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction heap-allocate/n16 */
  JITTER_INSTRUCTION_PROLOG_(heap-allocate/n16, heap_mallocate__n16, hot)
  { /* This block begins with definitions for heap-allocate/n16 . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       97
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         heap-allocate/n16
#   define JITTER_INSTRUCTION_NAME_AS_STRING "heap-allocate"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "heap-allocate/n16"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME heap_mallocate__n16

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is not branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is not branching: undefine branch
       macros so that they cannot be used by mistake. */
/* Locally poison JITTER_COMPUTED_GOTO . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_COMPUTED_GOTO")
# undef JITTER_COMPUTED_GOTO
# define JITTER_COMPUTED_GOTO JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_COMPUTED_GOTO, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_COMPUTED_GOTO
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_COMPUTED_GOTO . */

/* Locally poison JITTER_BRANCH . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_BRANCH")
# undef JITTER_BRANCH
# define JITTER_BRANCH JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_BRANCH, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_BRANCH
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_BRANCH . */

/* Locally poison JITTER_EXIT . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_EXIT")
# undef JITTER_EXIT
# define JITTER_EXIT JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_EXIT, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_EXIT
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_EXIT . */

  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0

    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 16L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0


#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of heap-allocate/n16 ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "heap-allocate/n16"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for heap-allocate/n16 . */
  {
/* User-specified code, user code block part: beginning. */

#ifdef JITTER_GC_STUB
    /* FIXME: I might want to merge this, along with the body of other
       instructions, into a macro.  This may still be factored in a different
       way, but the idea looks correct and promising. */
    /* Bump the allocation pointer, unconditionally.  Another instruction
       will check if it went out of the nursery. */
    const size_t allocation_size = JITTER_ARGN0;
    JITTERLISPVM_STATE_RUNTIME_FIELD (allocation_next) += allocation_size;
#else
    /* Nothing to do.  With the ordinary non-stub heap all the actual
       memory allocation happens in primitive-cons-special. */
#endif //#ifdef JITTER_GC_STUB
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for heap-allocate/n16 . */

  //fprintf (stderr, "..Executed instruction %s\n", "heap-allocate/n16");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the heap-allocate/n16 argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_EXIT")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_BRANCH")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_COMPUTED_GOTO")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(heap-allocate/n16, heap_mallocate__n16, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for heap-allocate/n16, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction heap-allocate/n24 */
  JITTER_INSTRUCTION_PROLOG_(heap-allocate/n24, heap_mallocate__n24, hot)
  { /* This block begins with definitions for heap-allocate/n24 . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       98
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         heap-allocate/n24
#   define JITTER_INSTRUCTION_NAME_AS_STRING "heap-allocate"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "heap-allocate/n24"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME heap_mallocate__n24

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is not branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is not branching: undefine branch
       macros so that they cannot be used by mistake. */
/* Locally poison JITTER_COMPUTED_GOTO . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_COMPUTED_GOTO")
# undef JITTER_COMPUTED_GOTO
# define JITTER_COMPUTED_GOTO JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_COMPUTED_GOTO, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_COMPUTED_GOTO
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_COMPUTED_GOTO . */

/* Locally poison JITTER_BRANCH . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_BRANCH")
# undef JITTER_BRANCH
# define JITTER_BRANCH JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_BRANCH, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_BRANCH
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_BRANCH . */

/* Locally poison JITTER_EXIT . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_EXIT")
# undef JITTER_EXIT
# define JITTER_EXIT JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_EXIT, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_EXIT
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_EXIT . */

  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0

    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 24L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0


#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of heap-allocate/n24 ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "heap-allocate/n24"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for heap-allocate/n24 . */
  {
/* User-specified code, user code block part: beginning. */

#ifdef JITTER_GC_STUB
    /* FIXME: I might want to merge this, along with the body of other
       instructions, into a macro.  This may still be factored in a different
       way, but the idea looks correct and promising. */
    /* Bump the allocation pointer, unconditionally.  Another instruction
       will check if it went out of the nursery. */
    const size_t allocation_size = JITTER_ARGN0;
    JITTERLISPVM_STATE_RUNTIME_FIELD (allocation_next) += allocation_size;
#else
    /* Nothing to do.  With the ordinary non-stub heap all the actual
       memory allocation happens in primitive-cons-special. */
#endif //#ifdef JITTER_GC_STUB
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for heap-allocate/n24 . */

  //fprintf (stderr, "..Executed instruction %s\n", "heap-allocate/n24");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the heap-allocate/n24 argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_EXIT")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_BRANCH")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_COMPUTED_GOTO")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(heap-allocate/n24, heap_mallocate__n24, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for heap-allocate/n24, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction heap-allocate/n32 */
  JITTER_INSTRUCTION_PROLOG_(heap-allocate/n32, heap_mallocate__n32, hot)
  { /* This block begins with definitions for heap-allocate/n32 . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       99
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         heap-allocate/n32
#   define JITTER_INSTRUCTION_NAME_AS_STRING "heap-allocate"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "heap-allocate/n32"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME heap_mallocate__n32

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is not branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is not branching: undefine branch
       macros so that they cannot be used by mistake. */
/* Locally poison JITTER_COMPUTED_GOTO . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_COMPUTED_GOTO")
# undef JITTER_COMPUTED_GOTO
# define JITTER_COMPUTED_GOTO JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_COMPUTED_GOTO, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_COMPUTED_GOTO
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_COMPUTED_GOTO . */

/* Locally poison JITTER_BRANCH . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_BRANCH")
# undef JITTER_BRANCH
# define JITTER_BRANCH JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_BRANCH, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_BRANCH
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_BRANCH . */

/* Locally poison JITTER_EXIT . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_EXIT")
# undef JITTER_EXIT
# define JITTER_EXIT JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_EXIT, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_EXIT
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_EXIT . */

  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0

    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 32L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0


#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of heap-allocate/n32 ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "heap-allocate/n32"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for heap-allocate/n32 . */
  {
/* User-specified code, user code block part: beginning. */

#ifdef JITTER_GC_STUB
    /* FIXME: I might want to merge this, along with the body of other
       instructions, into a macro.  This may still be factored in a different
       way, but the idea looks correct and promising. */
    /* Bump the allocation pointer, unconditionally.  Another instruction
       will check if it went out of the nursery. */
    const size_t allocation_size = JITTER_ARGN0;
    JITTERLISPVM_STATE_RUNTIME_FIELD (allocation_next) += allocation_size;
#else
    /* Nothing to do.  With the ordinary non-stub heap all the actual
       memory allocation happens in primitive-cons-special. */
#endif //#ifdef JITTER_GC_STUB
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for heap-allocate/n32 . */

  //fprintf (stderr, "..Executed instruction %s\n", "heap-allocate/n32");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the heap-allocate/n32 argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_EXIT")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_BRANCH")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_COMPUTED_GOTO")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(heap-allocate/n32, heap_mallocate__n32, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for heap-allocate/n32, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction heap-allocate/n36 */
  JITTER_INSTRUCTION_PROLOG_(heap-allocate/n36, heap_mallocate__n36, hot)
  { /* This block begins with definitions for heap-allocate/n36 . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       100
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         heap-allocate/n36
#   define JITTER_INSTRUCTION_NAME_AS_STRING "heap-allocate"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "heap-allocate/n36"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME heap_mallocate__n36

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is not branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is not branching: undefine branch
       macros so that they cannot be used by mistake. */
/* Locally poison JITTER_COMPUTED_GOTO . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_COMPUTED_GOTO")
# undef JITTER_COMPUTED_GOTO
# define JITTER_COMPUTED_GOTO JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_COMPUTED_GOTO, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_COMPUTED_GOTO
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_COMPUTED_GOTO . */

/* Locally poison JITTER_BRANCH . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_BRANCH")
# undef JITTER_BRANCH
# define JITTER_BRANCH JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_BRANCH, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_BRANCH
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_BRANCH . */

/* Locally poison JITTER_EXIT . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_EXIT")
# undef JITTER_EXIT
# define JITTER_EXIT JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_EXIT, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_EXIT
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_EXIT . */

  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0

    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 36L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0


#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of heap-allocate/n36 ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "heap-allocate/n36"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for heap-allocate/n36 . */
  {
/* User-specified code, user code block part: beginning. */

#ifdef JITTER_GC_STUB
    /* FIXME: I might want to merge this, along with the body of other
       instructions, into a macro.  This may still be factored in a different
       way, but the idea looks correct and promising. */
    /* Bump the allocation pointer, unconditionally.  Another instruction
       will check if it went out of the nursery. */
    const size_t allocation_size = JITTER_ARGN0;
    JITTERLISPVM_STATE_RUNTIME_FIELD (allocation_next) += allocation_size;
#else
    /* Nothing to do.  With the ordinary non-stub heap all the actual
       memory allocation happens in primitive-cons-special. */
#endif //#ifdef JITTER_GC_STUB
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for heap-allocate/n36 . */

  //fprintf (stderr, "..Executed instruction %s\n", "heap-allocate/n36");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the heap-allocate/n36 argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_EXIT")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_BRANCH")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_COMPUTED_GOTO")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(heap-allocate/n36, heap_mallocate__n36, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for heap-allocate/n36, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction heap-allocate/n48 */
  JITTER_INSTRUCTION_PROLOG_(heap-allocate/n48, heap_mallocate__n48, hot)
  { /* This block begins with definitions for heap-allocate/n48 . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       101
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         heap-allocate/n48
#   define JITTER_INSTRUCTION_NAME_AS_STRING "heap-allocate"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "heap-allocate/n48"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME heap_mallocate__n48

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is not branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is not branching: undefine branch
       macros so that they cannot be used by mistake. */
/* Locally poison JITTER_COMPUTED_GOTO . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_COMPUTED_GOTO")
# undef JITTER_COMPUTED_GOTO
# define JITTER_COMPUTED_GOTO JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_COMPUTED_GOTO, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_COMPUTED_GOTO
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_COMPUTED_GOTO . */

/* Locally poison JITTER_BRANCH . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_BRANCH")
# undef JITTER_BRANCH
# define JITTER_BRANCH JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_BRANCH, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_BRANCH
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_BRANCH . */

/* Locally poison JITTER_EXIT . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_EXIT")
# undef JITTER_EXIT
# define JITTER_EXIT JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_EXIT, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_EXIT
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_EXIT . */

  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0

    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 48L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0


#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of heap-allocate/n48 ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "heap-allocate/n48"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for heap-allocate/n48 . */
  {
/* User-specified code, user code block part: beginning. */

#ifdef JITTER_GC_STUB
    /* FIXME: I might want to merge this, along with the body of other
       instructions, into a macro.  This may still be factored in a different
       way, but the idea looks correct and promising. */
    /* Bump the allocation pointer, unconditionally.  Another instruction
       will check if it went out of the nursery. */
    const size_t allocation_size = JITTER_ARGN0;
    JITTERLISPVM_STATE_RUNTIME_FIELD (allocation_next) += allocation_size;
#else
    /* Nothing to do.  With the ordinary non-stub heap all the actual
       memory allocation happens in primitive-cons-special. */
#endif //#ifdef JITTER_GC_STUB
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for heap-allocate/n48 . */

  //fprintf (stderr, "..Executed instruction %s\n", "heap-allocate/n48");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the heap-allocate/n48 argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_EXIT")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_BRANCH")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_COMPUTED_GOTO")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(heap-allocate/n48, heap_mallocate__n48, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for heap-allocate/n48, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction heap-allocate/n52 */
  JITTER_INSTRUCTION_PROLOG_(heap-allocate/n52, heap_mallocate__n52, hot)
  { /* This block begins with definitions for heap-allocate/n52 . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       102
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         heap-allocate/n52
#   define JITTER_INSTRUCTION_NAME_AS_STRING "heap-allocate"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "heap-allocate/n52"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME heap_mallocate__n52

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is not branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is not branching: undefine branch
       macros so that they cannot be used by mistake. */
/* Locally poison JITTER_COMPUTED_GOTO . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_COMPUTED_GOTO")
# undef JITTER_COMPUTED_GOTO
# define JITTER_COMPUTED_GOTO JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_COMPUTED_GOTO, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_COMPUTED_GOTO
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_COMPUTED_GOTO . */

/* Locally poison JITTER_BRANCH . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_BRANCH")
# undef JITTER_BRANCH
# define JITTER_BRANCH JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_BRANCH, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_BRANCH
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_BRANCH . */

/* Locally poison JITTER_EXIT . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_EXIT")
# undef JITTER_EXIT
# define JITTER_EXIT JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_EXIT, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_EXIT
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_EXIT . */

  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0

    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 52L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0


#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of heap-allocate/n52 ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "heap-allocate/n52"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for heap-allocate/n52 . */
  {
/* User-specified code, user code block part: beginning. */

#ifdef JITTER_GC_STUB
    /* FIXME: I might want to merge this, along with the body of other
       instructions, into a macro.  This may still be factored in a different
       way, but the idea looks correct and promising. */
    /* Bump the allocation pointer, unconditionally.  Another instruction
       will check if it went out of the nursery. */
    const size_t allocation_size = JITTER_ARGN0;
    JITTERLISPVM_STATE_RUNTIME_FIELD (allocation_next) += allocation_size;
#else
    /* Nothing to do.  With the ordinary non-stub heap all the actual
       memory allocation happens in primitive-cons-special. */
#endif //#ifdef JITTER_GC_STUB
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for heap-allocate/n52 . */

  //fprintf (stderr, "..Executed instruction %s\n", "heap-allocate/n52");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the heap-allocate/n52 argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_EXIT")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_BRANCH")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_COMPUTED_GOTO")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(heap-allocate/n52, heap_mallocate__n52, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for heap-allocate/n52, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction heap-allocate/n64 */
  JITTER_INSTRUCTION_PROLOG_(heap-allocate/n64, heap_mallocate__n64, hot)
  { /* This block begins with definitions for heap-allocate/n64 . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       103
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         heap-allocate/n64
#   define JITTER_INSTRUCTION_NAME_AS_STRING "heap-allocate"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "heap-allocate/n64"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME heap_mallocate__n64

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is not branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is not branching: undefine branch
       macros so that they cannot be used by mistake. */
/* Locally poison JITTER_COMPUTED_GOTO . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_COMPUTED_GOTO")
# undef JITTER_COMPUTED_GOTO
# define JITTER_COMPUTED_GOTO JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_COMPUTED_GOTO, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_COMPUTED_GOTO
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_COMPUTED_GOTO . */

/* Locally poison JITTER_BRANCH . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_BRANCH")
# undef JITTER_BRANCH
# define JITTER_BRANCH JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_BRANCH, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_BRANCH
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_BRANCH . */

/* Locally poison JITTER_EXIT . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_EXIT")
# undef JITTER_EXIT
# define JITTER_EXIT JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_EXIT, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_EXIT
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_EXIT . */

  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0

    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 64L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0


#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of heap-allocate/n64 ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "heap-allocate/n64"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for heap-allocate/n64 . */
  {
/* User-specified code, user code block part: beginning. */

#ifdef JITTER_GC_STUB
    /* FIXME: I might want to merge this, along with the body of other
       instructions, into a macro.  This may still be factored in a different
       way, but the idea looks correct and promising. */
    /* Bump the allocation pointer, unconditionally.  Another instruction
       will check if it went out of the nursery. */
    const size_t allocation_size = JITTER_ARGN0;
    JITTERLISPVM_STATE_RUNTIME_FIELD (allocation_next) += allocation_size;
#else
    /* Nothing to do.  With the ordinary non-stub heap all the actual
       memory allocation happens in primitive-cons-special. */
#endif //#ifdef JITTER_GC_STUB
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for heap-allocate/n64 . */

  //fprintf (stderr, "..Executed instruction %s\n", "heap-allocate/n64");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the heap-allocate/n64 argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_EXIT")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_BRANCH")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_COMPUTED_GOTO")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(heap-allocate/n64, heap_mallocate__n64, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for heap-allocate/n64, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction heap-allocate/nR */
  JITTER_INSTRUCTION_PROLOG_(heap-allocate/nR, heap_mallocate__nR, cold)
  { /* This block begins with definitions for heap-allocate/nR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       104
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         heap-allocate/nR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "heap-allocate"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "heap-allocate/nR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME heap_mallocate__nR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is not branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is not branching: undefine branch
       macros so that they cannot be used by mistake. */
/* Locally poison JITTER_COMPUTED_GOTO . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_COMPUTED_GOTO")
# undef JITTER_COMPUTED_GOTO
# define JITTER_COMPUTED_GOTO JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_COMPUTED_GOTO, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_COMPUTED_GOTO
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_COMPUTED_GOTO . */

/* Locally poison JITTER_BRANCH . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_BRANCH")
# undef JITTER_BRANCH
# define JITTER_BRANCH JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_BRANCH, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_BRANCH
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_BRANCH . */

/* Locally poison JITTER_EXIT . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_EXIT")
# undef JITTER_EXIT
# define JITTER_EXIT JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_EXIT, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_EXIT
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_EXIT . */

  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1

    /* The 0th argument is a residual literal. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0


#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of heap-allocate/nR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "heap-allocate/nR"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for heap-allocate/nR . */
  {
/* User-specified code, user code block part: beginning. */

#ifdef JITTER_GC_STUB
    /* FIXME: I might want to merge this, along with the body of other
       instructions, into a macro.  This may still be factored in a different
       way, but the idea looks correct and promising. */
    /* Bump the allocation pointer, unconditionally.  Another instruction
       will check if it went out of the nursery. */
    const size_t allocation_size = JITTER_ARGN0;
    JITTERLISPVM_STATE_RUNTIME_FIELD (allocation_next) += allocation_size;
#else
    /* Nothing to do.  With the ordinary non-stub heap all the actual
       memory allocation happens in primitive-cons-special. */
#endif //#ifdef JITTER_GC_STUB
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for heap-allocate/nR . */

  //fprintf (stderr, "..Executed instruction %s\n", "heap-allocate/nR");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the heap-allocate/nR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_EXIT")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_BRANCH")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_COMPUTED_GOTO")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(heap-allocate/nR, heap_mallocate__nR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for heap-allocate/nR, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction literal-to-register/nR/%rR */
  JITTER_INSTRUCTION_PROLOG_(literal-to-register/nR/%rR, literal_mto_mregister__nR___rrR, cold)
  { /* This block begins with definitions for literal-to-register/nR/%rR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       105
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         literal-to-register/nR/%rR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "literal-to-register"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "literal-to-register/nR/%rR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME literal_mto_mregister__nR___rrR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is not branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is not branching: undefine branch
       macros so that they cannot be used by mistake. */
/* Locally poison JITTER_COMPUTED_GOTO . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_COMPUTED_GOTO")
# undef JITTER_COMPUTED_GOTO
# define JITTER_COMPUTED_GOTO JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_COMPUTED_GOTO, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_COMPUTED_GOTO
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_COMPUTED_GOTO . */

/* Locally poison JITTER_BRANCH . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_BRANCH")
# undef JITTER_BRANCH
# define JITTER_BRANCH JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_BRANCH, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_BRANCH
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_BRANCH . */

/* Locally poison JITTER_EXIT . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_EXIT")
# undef JITTER_EXIT
# define JITTER_EXIT JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_EXIT, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_EXIT
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_EXIT . */

  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 2

    /* The 0th argument is a residual literal. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a slow (therefore residual, passed as an offset)
        register. */
  /* Define a macro expanding to the slow register offset. */
#if defined(JITTER_DISPATCH_NO_THREADING)
# define JITTER_SLOW_REGISTER_OFFSET1 (JITTER_RESIDUAL_ARGUMENT_1.fixnum)
#elif defined (JITTER_DISPATCH_MINIMAL_THREADING)
# define JITTER_SLOW_REGISTER_OFFSET1 ((((union jitter_word*)jitter_ip)[1]).fixnum)
#else
# define JITTER_SLOW_REGISTER_OFFSET1 ((((union jitter_word*)jitter_ip)[2]).fixnum)
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
  /* Define a macro expanding to an l-value for the VM register content. */
#   define JITTER_ARG1  JITTER_SLOW_REGISTER_FROM_OFFSET(r, JITTER_SLOW_REGISTER_OFFSET1)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1


#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of literal-to-register/nR/%rR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "literal-to-register/nR/%rR"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for literal-to-register/nR/%rR . */
  {
/* User-specified code, user code block part: beginning. */

    JITTER_ARG1 = JITTER_ARGN0;
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for literal-to-register/nR/%rR . */

  //fprintf (stderr, "..Executed instruction %s\n", "literal-to-register/nR/%rR");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the literal-to-register/nR/%rR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_EXIT")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_BRANCH")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_COMPUTED_GOTO")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(literal-to-register/nR/%rR, literal_mto_mregister__nR___rrR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for literal-to-register/nR/%rR, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction nip */
  JITTER_INSTRUCTION_PROLOG_(nip, nip, hot)
  { /* This block begins with definitions for nip . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       106
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         nip
#   define JITTER_INSTRUCTION_NAME_AS_STRING "nip"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "nip"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME nip

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is not branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is not branching: undefine branch
       macros so that they cannot be used by mistake. */
/* Locally poison JITTER_COMPUTED_GOTO . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_COMPUTED_GOTO")
# undef JITTER_COMPUTED_GOTO
# define JITTER_COMPUTED_GOTO JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_COMPUTED_GOTO, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_COMPUTED_GOTO
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_COMPUTED_GOTO . */

/* Locally poison JITTER_BRANCH . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_BRANCH")
# undef JITTER_BRANCH
# define JITTER_BRANCH JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_BRANCH, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_BRANCH
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_BRANCH . */

/* Locally poison JITTER_EXIT . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_EXIT")
# undef JITTER_EXIT
# define JITTER_EXIT JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_EXIT, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_EXIT
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_EXIT . */

  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0


#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of nip ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "nip"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for nip . */
  {
/* User-specified code, user code block part: beginning. */

    JITTER_NIP_MAINSTACK();
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for nip . */

  //fprintf (stderr, "..Executed instruction %s\n", "nip");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the nip argument macros so they can't be used
       by mistake in the instruction body coming next. */

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_EXIT")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_BRANCH")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_COMPUTED_GOTO")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(nip, nip, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for nip, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction nip-drop */
  JITTER_INSTRUCTION_PROLOG_(nip-drop, nip_mdrop, hot)
  { /* This block begins with definitions for nip-drop . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       107
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         nip-drop
#   define JITTER_INSTRUCTION_NAME_AS_STRING "nip-drop"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "nip-drop"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME nip_mdrop

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is not branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is not branching: undefine branch
       macros so that they cannot be used by mistake. */
/* Locally poison JITTER_COMPUTED_GOTO . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_COMPUTED_GOTO")
# undef JITTER_COMPUTED_GOTO
# define JITTER_COMPUTED_GOTO JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_COMPUTED_GOTO, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_COMPUTED_GOTO
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_COMPUTED_GOTO . */

/* Locally poison JITTER_BRANCH . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_BRANCH")
# undef JITTER_BRANCH
# define JITTER_BRANCH JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_BRANCH, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_BRANCH
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_BRANCH . */

/* Locally poison JITTER_EXIT . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_EXIT")
# undef JITTER_EXIT
# define JITTER_EXIT JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_EXIT, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_EXIT
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_EXIT . */

  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0


#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of nip-drop ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "nip-drop"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for nip-drop . */
  {
/* User-specified code, user code block part: beginning. */

    JITTER_NIP_MAINSTACK();
    JITTER_DROP_MAINSTACK();
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for nip-drop . */

  //fprintf (stderr, "..Executed instruction %s\n", "nip-drop");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the nip-drop argument macros so they can't be used
       by mistake in the instruction body coming next. */

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_EXIT")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_BRANCH")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_COMPUTED_GOTO")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(nip-drop, nip_mdrop, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for nip-drop, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction nip-five */
  JITTER_INSTRUCTION_PROLOG_(nip-five, nip_mfive, hot)
  { /* This block begins with definitions for nip-five . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       108
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         nip-five
#   define JITTER_INSTRUCTION_NAME_AS_STRING "nip-five"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "nip-five"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME nip_mfive

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is not branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is not branching: undefine branch
       macros so that they cannot be used by mistake. */
/* Locally poison JITTER_COMPUTED_GOTO . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_COMPUTED_GOTO")
# undef JITTER_COMPUTED_GOTO
# define JITTER_COMPUTED_GOTO JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_COMPUTED_GOTO, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_COMPUTED_GOTO
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_COMPUTED_GOTO . */

/* Locally poison JITTER_BRANCH . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_BRANCH")
# undef JITTER_BRANCH
# define JITTER_BRANCH JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_BRANCH, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_BRANCH
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_BRANCH . */

/* Locally poison JITTER_EXIT . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_EXIT")
# undef JITTER_EXIT
# define JITTER_EXIT JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_EXIT, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_EXIT
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_EXIT . */

  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0


#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of nip-five ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "nip-five"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for nip-five . */
  {
/* User-specified code, user code block part: beginning. */

    JITTER_NIP_MAINSTACK();
    JITTER_NIP_MAINSTACK();
    JITTER_NIP_MAINSTACK();
    JITTER_NIP_MAINSTACK();
    JITTER_NIP_MAINSTACK();
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for nip-five . */

  //fprintf (stderr, "..Executed instruction %s\n", "nip-five");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the nip-five argument macros so they can't be used
       by mistake in the instruction body coming next. */

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_EXIT")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_BRANCH")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_COMPUTED_GOTO")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(nip-five, nip_mfive, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for nip-five, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction nip-five-drop */
  JITTER_INSTRUCTION_PROLOG_(nip-five-drop, nip_mfive_mdrop, hot)
  { /* This block begins with definitions for nip-five-drop . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       109
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         nip-five-drop
#   define JITTER_INSTRUCTION_NAME_AS_STRING "nip-five-drop"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "nip-five-drop"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME nip_mfive_mdrop

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is not branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is not branching: undefine branch
       macros so that they cannot be used by mistake. */
/* Locally poison JITTER_COMPUTED_GOTO . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_COMPUTED_GOTO")
# undef JITTER_COMPUTED_GOTO
# define JITTER_COMPUTED_GOTO JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_COMPUTED_GOTO, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_COMPUTED_GOTO
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_COMPUTED_GOTO . */

/* Locally poison JITTER_BRANCH . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_BRANCH")
# undef JITTER_BRANCH
# define JITTER_BRANCH JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_BRANCH, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_BRANCH
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_BRANCH . */

/* Locally poison JITTER_EXIT . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_EXIT")
# undef JITTER_EXIT
# define JITTER_EXIT JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_EXIT, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_EXIT
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_EXIT . */

  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0


#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of nip-five-drop ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "nip-five-drop"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for nip-five-drop . */
  {
/* User-specified code, user code block part: beginning. */

    JITTER_NIP_MAINSTACK();
    JITTER_NIP_MAINSTACK();
    JITTER_NIP_MAINSTACK();
    JITTER_NIP_MAINSTACK();
    JITTER_NIP_MAINSTACK();
    JITTER_DROP_MAINSTACK();
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for nip-five-drop . */

  //fprintf (stderr, "..Executed instruction %s\n", "nip-five-drop");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the nip-five-drop argument macros so they can't be used
       by mistake in the instruction body coming next. */

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_EXIT")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_BRANCH")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_COMPUTED_GOTO")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(nip-five-drop, nip_mfive_mdrop, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for nip-five-drop, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction nip-four */
  JITTER_INSTRUCTION_PROLOG_(nip-four, nip_mfour, hot)
  { /* This block begins with definitions for nip-four . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       110
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         nip-four
#   define JITTER_INSTRUCTION_NAME_AS_STRING "nip-four"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "nip-four"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME nip_mfour

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is not branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is not branching: undefine branch
       macros so that they cannot be used by mistake. */
/* Locally poison JITTER_COMPUTED_GOTO . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_COMPUTED_GOTO")
# undef JITTER_COMPUTED_GOTO
# define JITTER_COMPUTED_GOTO JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_COMPUTED_GOTO, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_COMPUTED_GOTO
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_COMPUTED_GOTO . */

/* Locally poison JITTER_BRANCH . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_BRANCH")
# undef JITTER_BRANCH
# define JITTER_BRANCH JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_BRANCH, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_BRANCH
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_BRANCH . */

/* Locally poison JITTER_EXIT . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_EXIT")
# undef JITTER_EXIT
# define JITTER_EXIT JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_EXIT, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_EXIT
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_EXIT . */

  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0


#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of nip-four ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "nip-four"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for nip-four . */
  {
/* User-specified code, user code block part: beginning. */

    JITTER_NIP_MAINSTACK();
    JITTER_NIP_MAINSTACK();
    JITTER_NIP_MAINSTACK();
    JITTER_NIP_MAINSTACK();
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for nip-four . */

  //fprintf (stderr, "..Executed instruction %s\n", "nip-four");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the nip-four argument macros so they can't be used
       by mistake in the instruction body coming next. */

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_EXIT")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_BRANCH")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_COMPUTED_GOTO")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(nip-four, nip_mfour, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for nip-four, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction nip-four-drop */
  JITTER_INSTRUCTION_PROLOG_(nip-four-drop, nip_mfour_mdrop, hot)
  { /* This block begins with definitions for nip-four-drop . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       111
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         nip-four-drop
#   define JITTER_INSTRUCTION_NAME_AS_STRING "nip-four-drop"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "nip-four-drop"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME nip_mfour_mdrop

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is not branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is not branching: undefine branch
       macros so that they cannot be used by mistake. */
/* Locally poison JITTER_COMPUTED_GOTO . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_COMPUTED_GOTO")
# undef JITTER_COMPUTED_GOTO
# define JITTER_COMPUTED_GOTO JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_COMPUTED_GOTO, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_COMPUTED_GOTO
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_COMPUTED_GOTO . */

/* Locally poison JITTER_BRANCH . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_BRANCH")
# undef JITTER_BRANCH
# define JITTER_BRANCH JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_BRANCH, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_BRANCH
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_BRANCH . */

/* Locally poison JITTER_EXIT . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_EXIT")
# undef JITTER_EXIT
# define JITTER_EXIT JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_EXIT, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_EXIT
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_EXIT . */

  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0


#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of nip-four-drop ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "nip-four-drop"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for nip-four-drop . */
  {
/* User-specified code, user code block part: beginning. */

    JITTER_NIP_MAINSTACK();
    JITTER_NIP_MAINSTACK();
    JITTER_NIP_MAINSTACK();
    JITTER_NIP_MAINSTACK();
    JITTER_DROP_MAINSTACK();
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for nip-four-drop . */

  //fprintf (stderr, "..Executed instruction %s\n", "nip-four-drop");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the nip-four-drop argument macros so they can't be used
       by mistake in the instruction body coming next. */

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_EXIT")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_BRANCH")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_COMPUTED_GOTO")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(nip-four-drop, nip_mfour_mdrop, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for nip-four-drop, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction nip-push-literal/nR */
  JITTER_INSTRUCTION_PROLOG_(nip-push-literal/nR, nip_mpush_mliteral__nR, cold)
  { /* This block begins with definitions for nip-push-literal/nR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       112
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         nip-push-literal/nR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "nip-push-literal"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "nip-push-literal/nR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME nip_mpush_mliteral__nR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is not branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is not branching: undefine branch
       macros so that they cannot be used by mistake. */
/* Locally poison JITTER_COMPUTED_GOTO . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_COMPUTED_GOTO")
# undef JITTER_COMPUTED_GOTO
# define JITTER_COMPUTED_GOTO JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_COMPUTED_GOTO, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_COMPUTED_GOTO
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_COMPUTED_GOTO . */

/* Locally poison JITTER_BRANCH . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_BRANCH")
# undef JITTER_BRANCH
# define JITTER_BRANCH JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_BRANCH, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_BRANCH
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_BRANCH . */

/* Locally poison JITTER_EXIT . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_EXIT")
# undef JITTER_EXIT
# define JITTER_EXIT JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_EXIT, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_EXIT
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_EXIT . */

  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1

    /* The 0th argument is a residual literal. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0


#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of nip-push-literal/nR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "nip-push-literal/nR"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for nip-push-literal/nR . */
  {
/* User-specified code, user code block part: beginning. */

    JITTER_UNDER_TOP_MAINSTACK() = JITTER_TOP_MAINSTACK();
    JITTER_TOP_MAINSTACK() = JITTER_ARGN0;
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for nip-push-literal/nR . */

  //fprintf (stderr, "..Executed instruction %s\n", "nip-push-literal/nR");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the nip-push-literal/nR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_EXIT")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_BRANCH")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_COMPUTED_GOTO")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(nip-push-literal/nR, nip_mpush_mliteral__nR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for nip-push-literal/nR, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction nip-push-register/%rR */
  JITTER_INSTRUCTION_PROLOG_(nip-push-register/%rR, nip_mpush_mregister___rrR, cold)
  { /* This block begins with definitions for nip-push-register/%rR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       113
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         nip-push-register/%rR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "nip-push-register"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "nip-push-register/%rR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME nip_mpush_mregister___rrR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is not branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is not branching: undefine branch
       macros so that they cannot be used by mistake. */
/* Locally poison JITTER_COMPUTED_GOTO . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_COMPUTED_GOTO")
# undef JITTER_COMPUTED_GOTO
# define JITTER_COMPUTED_GOTO JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_COMPUTED_GOTO, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_COMPUTED_GOTO
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_COMPUTED_GOTO . */

/* Locally poison JITTER_BRANCH . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_BRANCH")
# undef JITTER_BRANCH
# define JITTER_BRANCH JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_BRANCH, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_BRANCH
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_BRANCH . */

/* Locally poison JITTER_EXIT . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_EXIT")
# undef JITTER_EXIT
# define JITTER_EXIT JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_EXIT, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_EXIT
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_EXIT . */

  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1

    /* The 0th argument is a slow (therefore residual, passed as an offset)
        register. */
  /* Define a macro expanding to the slow register offset. */
#if defined(JITTER_DISPATCH_NO_THREADING)
# define JITTER_SLOW_REGISTER_OFFSET0 (JITTER_RESIDUAL_ARGUMENT_0.fixnum)
#elif defined (JITTER_DISPATCH_MINIMAL_THREADING)
# define JITTER_SLOW_REGISTER_OFFSET0 ((((union jitter_word*)jitter_ip)[0]).fixnum)
#else
# define JITTER_SLOW_REGISTER_OFFSET0 ((((union jitter_word*)jitter_ip)[1]).fixnum)
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
  /* Define a macro expanding to an l-value for the VM register content. */
#   define JITTER_ARG0  JITTER_SLOW_REGISTER_FROM_OFFSET(r, JITTER_SLOW_REGISTER_OFFSET0)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0


#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of nip-push-register/%rR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "nip-push-register/%rR"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for nip-push-register/%rR . */
  {
/* User-specified code, user code block part: beginning. */

    JITTER_UNDER_TOP_MAINSTACK() = JITTER_TOP_MAINSTACK();
    JITTER_TOP_MAINSTACK() = JITTER_ARG0;
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for nip-push-register/%rR . */

  //fprintf (stderr, "..Executed instruction %s\n", "nip-push-register/%rR");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the nip-push-register/%rR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_EXIT")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_BRANCH")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_COMPUTED_GOTO")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(nip-push-register/%rR, nip_mpush_mregister___rrR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for nip-push-register/%rR, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction nip-six */
  JITTER_INSTRUCTION_PROLOG_(nip-six, nip_msix, hot)
  { /* This block begins with definitions for nip-six . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       114
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         nip-six
#   define JITTER_INSTRUCTION_NAME_AS_STRING "nip-six"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "nip-six"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME nip_msix

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is not branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is not branching: undefine branch
       macros so that they cannot be used by mistake. */
/* Locally poison JITTER_COMPUTED_GOTO . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_COMPUTED_GOTO")
# undef JITTER_COMPUTED_GOTO
# define JITTER_COMPUTED_GOTO JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_COMPUTED_GOTO, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_COMPUTED_GOTO
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_COMPUTED_GOTO . */

/* Locally poison JITTER_BRANCH . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_BRANCH")
# undef JITTER_BRANCH
# define JITTER_BRANCH JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_BRANCH, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_BRANCH
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_BRANCH . */

/* Locally poison JITTER_EXIT . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_EXIT")
# undef JITTER_EXIT
# define JITTER_EXIT JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_EXIT, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_EXIT
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_EXIT . */

  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0


#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of nip-six ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "nip-six"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for nip-six . */
  {
/* User-specified code, user code block part: beginning. */

    JITTER_NIP_MAINSTACK();
    JITTER_NIP_MAINSTACK();
    JITTER_NIP_MAINSTACK();
    JITTER_NIP_MAINSTACK();
    JITTER_NIP_MAINSTACK();
    JITTER_NIP_MAINSTACK();
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for nip-six . */

  //fprintf (stderr, "..Executed instruction %s\n", "nip-six");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the nip-six argument macros so they can't be used
       by mistake in the instruction body coming next. */

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_EXIT")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_BRANCH")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_COMPUTED_GOTO")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(nip-six, nip_msix, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for nip-six, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction nip-six-drop */
  JITTER_INSTRUCTION_PROLOG_(nip-six-drop, nip_msix_mdrop, hot)
  { /* This block begins with definitions for nip-six-drop . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       115
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         nip-six-drop
#   define JITTER_INSTRUCTION_NAME_AS_STRING "nip-six-drop"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "nip-six-drop"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME nip_msix_mdrop

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is not branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is not branching: undefine branch
       macros so that they cannot be used by mistake. */
/* Locally poison JITTER_COMPUTED_GOTO . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_COMPUTED_GOTO")
# undef JITTER_COMPUTED_GOTO
# define JITTER_COMPUTED_GOTO JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_COMPUTED_GOTO, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_COMPUTED_GOTO
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_COMPUTED_GOTO . */

/* Locally poison JITTER_BRANCH . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_BRANCH")
# undef JITTER_BRANCH
# define JITTER_BRANCH JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_BRANCH, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_BRANCH
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_BRANCH . */

/* Locally poison JITTER_EXIT . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_EXIT")
# undef JITTER_EXIT
# define JITTER_EXIT JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_EXIT, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_EXIT
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_EXIT . */

  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0


#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of nip-six-drop ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "nip-six-drop"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for nip-six-drop . */
  {
/* User-specified code, user code block part: beginning. */

    JITTER_NIP_MAINSTACK();
    JITTER_NIP_MAINSTACK();
    JITTER_NIP_MAINSTACK();
    JITTER_NIP_MAINSTACK();
    JITTER_NIP_MAINSTACK();
    JITTER_NIP_MAINSTACK();
    JITTER_DROP_MAINSTACK();
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for nip-six-drop . */

  //fprintf (stderr, "..Executed instruction %s\n", "nip-six-drop");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the nip-six-drop argument macros so they can't be used
       by mistake in the instruction body coming next. */

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_EXIT")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_BRANCH")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_COMPUTED_GOTO")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(nip-six-drop, nip_msix_mdrop, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for nip-six-drop, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction nip-three */
  JITTER_INSTRUCTION_PROLOG_(nip-three, nip_mthree, hot)
  { /* This block begins with definitions for nip-three . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       116
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         nip-three
#   define JITTER_INSTRUCTION_NAME_AS_STRING "nip-three"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "nip-three"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME nip_mthree

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is not branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is not branching: undefine branch
       macros so that they cannot be used by mistake. */
/* Locally poison JITTER_COMPUTED_GOTO . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_COMPUTED_GOTO")
# undef JITTER_COMPUTED_GOTO
# define JITTER_COMPUTED_GOTO JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_COMPUTED_GOTO, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_COMPUTED_GOTO
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_COMPUTED_GOTO . */

/* Locally poison JITTER_BRANCH . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_BRANCH")
# undef JITTER_BRANCH
# define JITTER_BRANCH JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_BRANCH, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_BRANCH
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_BRANCH . */

/* Locally poison JITTER_EXIT . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_EXIT")
# undef JITTER_EXIT
# define JITTER_EXIT JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_EXIT, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_EXIT
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_EXIT . */

  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0


#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of nip-three ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "nip-three"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for nip-three . */
  {
/* User-specified code, user code block part: beginning. */

    JITTER_NIP_MAINSTACK();
    JITTER_NIP_MAINSTACK();
    JITTER_NIP_MAINSTACK();
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for nip-three . */

  //fprintf (stderr, "..Executed instruction %s\n", "nip-three");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the nip-three argument macros so they can't be used
       by mistake in the instruction body coming next. */

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_EXIT")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_BRANCH")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_COMPUTED_GOTO")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(nip-three, nip_mthree, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for nip-three, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction nip-three-drop */
  JITTER_INSTRUCTION_PROLOG_(nip-three-drop, nip_mthree_mdrop, hot)
  { /* This block begins with definitions for nip-three-drop . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       117
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         nip-three-drop
#   define JITTER_INSTRUCTION_NAME_AS_STRING "nip-three-drop"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "nip-three-drop"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME nip_mthree_mdrop

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is not branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is not branching: undefine branch
       macros so that they cannot be used by mistake. */
/* Locally poison JITTER_COMPUTED_GOTO . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_COMPUTED_GOTO")
# undef JITTER_COMPUTED_GOTO
# define JITTER_COMPUTED_GOTO JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_COMPUTED_GOTO, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_COMPUTED_GOTO
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_COMPUTED_GOTO . */

/* Locally poison JITTER_BRANCH . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_BRANCH")
# undef JITTER_BRANCH
# define JITTER_BRANCH JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_BRANCH, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_BRANCH
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_BRANCH . */

/* Locally poison JITTER_EXIT . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_EXIT")
# undef JITTER_EXIT
# define JITTER_EXIT JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_EXIT, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_EXIT
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_EXIT . */

  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0


#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of nip-three-drop ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "nip-three-drop"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for nip-three-drop . */
  {
/* User-specified code, user code block part: beginning. */

    JITTER_NIP_MAINSTACK();
    JITTER_NIP_MAINSTACK();
    JITTER_NIP_MAINSTACK();
    JITTER_DROP_MAINSTACK();
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for nip-three-drop . */

  //fprintf (stderr, "..Executed instruction %s\n", "nip-three-drop");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the nip-three-drop argument macros so they can't be used
       by mistake in the instruction body coming next. */

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_EXIT")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_BRANCH")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_COMPUTED_GOTO")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(nip-three-drop, nip_mthree_mdrop, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for nip-three-drop, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction nip-two */
  JITTER_INSTRUCTION_PROLOG_(nip-two, nip_mtwo, hot)
  { /* This block begins with definitions for nip-two . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       118
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         nip-two
#   define JITTER_INSTRUCTION_NAME_AS_STRING "nip-two"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "nip-two"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME nip_mtwo

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is not branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is not branching: undefine branch
       macros so that they cannot be used by mistake. */
/* Locally poison JITTER_COMPUTED_GOTO . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_COMPUTED_GOTO")
# undef JITTER_COMPUTED_GOTO
# define JITTER_COMPUTED_GOTO JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_COMPUTED_GOTO, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_COMPUTED_GOTO
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_COMPUTED_GOTO . */

/* Locally poison JITTER_BRANCH . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_BRANCH")
# undef JITTER_BRANCH
# define JITTER_BRANCH JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_BRANCH, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_BRANCH
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_BRANCH . */

/* Locally poison JITTER_EXIT . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_EXIT")
# undef JITTER_EXIT
# define JITTER_EXIT JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_EXIT, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_EXIT
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_EXIT . */

  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0


#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of nip-two ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "nip-two"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for nip-two . */
  {
/* User-specified code, user code block part: beginning. */

    JITTER_NIP_MAINSTACK();
    JITTER_NIP_MAINSTACK();
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for nip-two . */

  //fprintf (stderr, "..Executed instruction %s\n", "nip-two");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the nip-two argument macros so they can't be used
       by mistake in the instruction body coming next. */

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_EXIT")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_BRANCH")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_COMPUTED_GOTO")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(nip-two, nip_mtwo, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for nip-two, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction nip-two-drop */
  JITTER_INSTRUCTION_PROLOG_(nip-two-drop, nip_mtwo_mdrop, hot)
  { /* This block begins with definitions for nip-two-drop . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       119
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         nip-two-drop
#   define JITTER_INSTRUCTION_NAME_AS_STRING "nip-two-drop"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "nip-two-drop"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME nip_mtwo_mdrop

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is not branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is not branching: undefine branch
       macros so that they cannot be used by mistake. */
/* Locally poison JITTER_COMPUTED_GOTO . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_COMPUTED_GOTO")
# undef JITTER_COMPUTED_GOTO
# define JITTER_COMPUTED_GOTO JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_COMPUTED_GOTO, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_COMPUTED_GOTO
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_COMPUTED_GOTO . */

/* Locally poison JITTER_BRANCH . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_BRANCH")
# undef JITTER_BRANCH
# define JITTER_BRANCH JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_BRANCH, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_BRANCH
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_BRANCH . */

/* Locally poison JITTER_EXIT . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_EXIT")
# undef JITTER_EXIT
# define JITTER_EXIT JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_EXIT, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_EXIT
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_EXIT . */

  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0


#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of nip-two-drop ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "nip-two-drop"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for nip-two-drop . */
  {
/* User-specified code, user code block part: beginning. */

    JITTER_NIP_MAINSTACK();
    JITTER_NIP_MAINSTACK();
    JITTER_DROP_MAINSTACK();
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for nip-two-drop . */

  //fprintf (stderr, "..Executed instruction %s\n", "nip-two-drop");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the nip-two-drop argument macros so they can't be used
       by mistake in the instruction body coming next. */

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_EXIT")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_BRANCH")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_COMPUTED_GOTO")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(nip-two-drop, nip_mtwo_mdrop, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for nip-two-drop, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction nop */
  JITTER_INSTRUCTION_PROLOG_(nop, nop, hot)
  { /* This block begins with definitions for nop . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       120
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         nop
#   define JITTER_INSTRUCTION_NAME_AS_STRING "nop"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "nop"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME nop

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is not branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is not branching: undefine branch
       macros so that they cannot be used by mistake. */
/* Locally poison JITTER_COMPUTED_GOTO . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_COMPUTED_GOTO")
# undef JITTER_COMPUTED_GOTO
# define JITTER_COMPUTED_GOTO JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_COMPUTED_GOTO, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_COMPUTED_GOTO
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_COMPUTED_GOTO . */

/* Locally poison JITTER_BRANCH . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_BRANCH")
# undef JITTER_BRANCH
# define JITTER_BRANCH JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_BRANCH, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_BRANCH
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_BRANCH . */

/* Locally poison JITTER_EXIT . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_EXIT")
# undef JITTER_EXIT
# define JITTER_EXIT JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_EXIT, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_EXIT
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_EXIT . */

  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0


#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of nop ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "nop"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for nop . */
  {
/* User-specified code, user code block part: beginning. */

  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for nop . */

  //fprintf (stderr, "..Executed instruction %s\n", "nop");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the nop argument macros so they can't be used
       by mistake in the instruction body coming next. */

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_EXIT")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_BRANCH")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_COMPUTED_GOTO")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(nop, nop, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for nop, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction one-minus-register/%rR/%rR/fR */
  JITTER_INSTRUCTION_PROLOG_(one-minus-register/%rR/%rR/fR, one_mminus_mregister___rrR___rrR__fR, cold)
  { /* This block begins with definitions for one-minus-register/%rR/%rR/fR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       121
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         one-minus-register/%rR/%rR/fR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "one-minus-register"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "one-minus-register/%rR/%rR/fR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME one_mminus_mregister___rrR___rrR__fR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity varies depending on whether we have fast labels. */
#ifdef JITTER_HAVE_PATCH_IN
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 2
#else
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 3
#endif // #ifdef JITTER_HAVE_PATCH_IN

  /* Define argument-access macros for one-minus-register/%rR/%rR/fR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a slow (therefore residual, passed as an offset)
        register. */
  /* Define a macro expanding to the slow register offset. */
#if defined(JITTER_DISPATCH_NO_THREADING)
# define JITTER_SLOW_REGISTER_OFFSET0 (JITTER_RESIDUAL_ARGUMENT_0.fixnum)
#elif defined (JITTER_DISPATCH_MINIMAL_THREADING)
# define JITTER_SLOW_REGISTER_OFFSET0 ((((union jitter_word*)jitter_ip)[0]).fixnum)
#else
# define JITTER_SLOW_REGISTER_OFFSET0 ((((union jitter_word*)jitter_ip)[1]).fixnum)
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
  /* Define a macro expanding to an l-value for the VM register content. */
#   define JITTER_ARG0  JITTER_SLOW_REGISTER_FROM_OFFSET(r, JITTER_SLOW_REGISTER_OFFSET0)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)

    /* The 1th argument is a slow (therefore residual, passed as an offset)
        register. */
  /* Define a macro expanding to the slow register offset. */
#if defined(JITTER_DISPATCH_NO_THREADING)
# define JITTER_SLOW_REGISTER_OFFSET1 (JITTER_RESIDUAL_ARGUMENT_1.fixnum)
#elif defined (JITTER_DISPATCH_MINIMAL_THREADING)
# define JITTER_SLOW_REGISTER_OFFSET1 ((((union jitter_word*)jitter_ip)[1]).fixnum)
#else
# define JITTER_SLOW_REGISTER_OFFSET1 ((((union jitter_word*)jitter_ip)[2]).fixnum)
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
  /* Define a macro expanding to an l-value for the VM register content. */
#   define JITTER_ARG1  JITTER_SLOW_REGISTER_FROM_OFFSET(r, JITTER_SLOW_REGISTER_OFFSET1)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)

    /* The 2th argument is a "residual" fast label.  Define its
       _ARGF macro as the residual *index* (counting only fast labels, 0-based),
       so that at replication time we know what instruction address to patch in. */
#   define JITTER_ARGF2 0
    /* JITTER_ARG2 is intentionally not defined for a fast label. */

#   define JITTER_ARGN2 (JITTER_ARG2.fixnum)
#   define JITTER_ARGU2 (JITTER_ARG2.ufixnum)
#   define JITTER_ARGP2 (JITTER_ARG2.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
    /* The 0th argument is a slow (therefore residual, passed as an offset)
        register. */
  /* Define a macro expanding to the slow register offset. */
#if defined(JITTER_DISPATCH_NO_THREADING)
# define JITTER_SLOW_REGISTER_OFFSET0 (JITTER_RESIDUAL_ARGUMENT_0.fixnum)
#elif defined (JITTER_DISPATCH_MINIMAL_THREADING)
# define JITTER_SLOW_REGISTER_OFFSET0 ((((union jitter_word*)jitter_ip)[0]).fixnum)
#else
# define JITTER_SLOW_REGISTER_OFFSET0 ((((union jitter_word*)jitter_ip)[1]).fixnum)
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
  /* Define a macro expanding to an l-value for the VM register content. */
#   define JITTER_ARG0  JITTER_SLOW_REGISTER_FROM_OFFSET(r, JITTER_SLOW_REGISTER_OFFSET0)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a slow (therefore residual, passed as an offset)
        register. */
  /* Define a macro expanding to the slow register offset. */
#if defined(JITTER_DISPATCH_NO_THREADING)
# define JITTER_SLOW_REGISTER_OFFSET1 (JITTER_RESIDUAL_ARGUMENT_1.fixnum)
#elif defined (JITTER_DISPATCH_MINIMAL_THREADING)
# define JITTER_SLOW_REGISTER_OFFSET1 ((((union jitter_word*)jitter_ip)[1]).fixnum)
#else
# define JITTER_SLOW_REGISTER_OFFSET1 ((((union jitter_word*)jitter_ip)[2]).fixnum)
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
  /* Define a macro expanding to an l-value for the VM register content. */
#   define JITTER_ARG1  JITTER_SLOW_REGISTER_FROM_OFFSET(r, JITTER_SLOW_REGISTER_OFFSET1)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG2  JITTER_RESIDUAL_ARGUMENT_2
    JITTER_MARK_RESIDUAL_2_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[2])
#else
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[3])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN2 (JITTER_ARG2.fixnum)
#   define JITTER_ARGU2 (JITTER_ARG2.ufixnum)
#   define JITTER_ARGP2 (JITTER_ARG2.pointer)
#   define JITTER_ARGF2 JITTER_ARGP2

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of one-minus-register/%rR/%rR/fR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "one-minus-register/%rR/%rR/fR"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for one-minus-register/%rR/%rR/fR . */
  {
/* User-specified code, user code block part: beginning. */

#if ! defined (JITTERLISP_UNSAFE)
    JITTERLISP_BRANCH_FAST_UNLESS_FIXNUM (JITTER_ARG0, JITTER_ARGF2);
#endif
    JITTERLISP_1MINUS_OR_OVERFLOW_(JITTER_ARG1,
                                   JITTER_ARG0,
                                   JITTER_ARGF2);
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for one-minus-register/%rR/%rR/fR . */

  //fprintf (stderr, "..Executed instruction %s\n", "one-minus-register/%rR/%rR/fR");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the one-minus-register/%rR/%rR/fR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1
#   undef JITTER_SLOW_REGISTER_OFFSET2
#   undef JITTER_ARG2
#   undef JITTER_ARGN2
#   undef JITTER_ARGU2
#   undef JITTER_ARGP2
#   undef JITTER_ARGF2

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(one-minus-register/%rR/%rR/fR, one_mminus_mregister___rrR___rrR__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for one-minus-register/%rR/%rR/fR, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction one-plus-register/%rR/%rR/fR */
  JITTER_INSTRUCTION_PROLOG_(one-plus-register/%rR/%rR/fR, one_mplus_mregister___rrR___rrR__fR, cold)
  { /* This block begins with definitions for one-plus-register/%rR/%rR/fR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       122
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         one-plus-register/%rR/%rR/fR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "one-plus-register"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "one-plus-register/%rR/%rR/fR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME one_mplus_mregister___rrR___rrR__fR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity varies depending on whether we have fast labels. */
#ifdef JITTER_HAVE_PATCH_IN
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 2
#else
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 3
#endif // #ifdef JITTER_HAVE_PATCH_IN

  /* Define argument-access macros for one-plus-register/%rR/%rR/fR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a slow (therefore residual, passed as an offset)
        register. */
  /* Define a macro expanding to the slow register offset. */
#if defined(JITTER_DISPATCH_NO_THREADING)
# define JITTER_SLOW_REGISTER_OFFSET0 (JITTER_RESIDUAL_ARGUMENT_0.fixnum)
#elif defined (JITTER_DISPATCH_MINIMAL_THREADING)
# define JITTER_SLOW_REGISTER_OFFSET0 ((((union jitter_word*)jitter_ip)[0]).fixnum)
#else
# define JITTER_SLOW_REGISTER_OFFSET0 ((((union jitter_word*)jitter_ip)[1]).fixnum)
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
  /* Define a macro expanding to an l-value for the VM register content. */
#   define JITTER_ARG0  JITTER_SLOW_REGISTER_FROM_OFFSET(r, JITTER_SLOW_REGISTER_OFFSET0)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)

    /* The 1th argument is a slow (therefore residual, passed as an offset)
        register. */
  /* Define a macro expanding to the slow register offset. */
#if defined(JITTER_DISPATCH_NO_THREADING)
# define JITTER_SLOW_REGISTER_OFFSET1 (JITTER_RESIDUAL_ARGUMENT_1.fixnum)
#elif defined (JITTER_DISPATCH_MINIMAL_THREADING)
# define JITTER_SLOW_REGISTER_OFFSET1 ((((union jitter_word*)jitter_ip)[1]).fixnum)
#else
# define JITTER_SLOW_REGISTER_OFFSET1 ((((union jitter_word*)jitter_ip)[2]).fixnum)
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
  /* Define a macro expanding to an l-value for the VM register content. */
#   define JITTER_ARG1  JITTER_SLOW_REGISTER_FROM_OFFSET(r, JITTER_SLOW_REGISTER_OFFSET1)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)

    /* The 2th argument is a "residual" fast label.  Define its
       _ARGF macro as the residual *index* (counting only fast labels, 0-based),
       so that at replication time we know what instruction address to patch in. */
#   define JITTER_ARGF2 0
    /* JITTER_ARG2 is intentionally not defined for a fast label. */

#   define JITTER_ARGN2 (JITTER_ARG2.fixnum)
#   define JITTER_ARGU2 (JITTER_ARG2.ufixnum)
#   define JITTER_ARGP2 (JITTER_ARG2.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
    /* The 0th argument is a slow (therefore residual, passed as an offset)
        register. */
  /* Define a macro expanding to the slow register offset. */
#if defined(JITTER_DISPATCH_NO_THREADING)
# define JITTER_SLOW_REGISTER_OFFSET0 (JITTER_RESIDUAL_ARGUMENT_0.fixnum)
#elif defined (JITTER_DISPATCH_MINIMAL_THREADING)
# define JITTER_SLOW_REGISTER_OFFSET0 ((((union jitter_word*)jitter_ip)[0]).fixnum)
#else
# define JITTER_SLOW_REGISTER_OFFSET0 ((((union jitter_word*)jitter_ip)[1]).fixnum)
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
  /* Define a macro expanding to an l-value for the VM register content. */
#   define JITTER_ARG0  JITTER_SLOW_REGISTER_FROM_OFFSET(r, JITTER_SLOW_REGISTER_OFFSET0)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a slow (therefore residual, passed as an offset)
        register. */
  /* Define a macro expanding to the slow register offset. */
#if defined(JITTER_DISPATCH_NO_THREADING)
# define JITTER_SLOW_REGISTER_OFFSET1 (JITTER_RESIDUAL_ARGUMENT_1.fixnum)
#elif defined (JITTER_DISPATCH_MINIMAL_THREADING)
# define JITTER_SLOW_REGISTER_OFFSET1 ((((union jitter_word*)jitter_ip)[1]).fixnum)
#else
# define JITTER_SLOW_REGISTER_OFFSET1 ((((union jitter_word*)jitter_ip)[2]).fixnum)
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
  /* Define a macro expanding to an l-value for the VM register content. */
#   define JITTER_ARG1  JITTER_SLOW_REGISTER_FROM_OFFSET(r, JITTER_SLOW_REGISTER_OFFSET1)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG2  JITTER_RESIDUAL_ARGUMENT_2
    JITTER_MARK_RESIDUAL_2_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[2])
#else
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[3])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN2 (JITTER_ARG2.fixnum)
#   define JITTER_ARGU2 (JITTER_ARG2.ufixnum)
#   define JITTER_ARGP2 (JITTER_ARG2.pointer)
#   define JITTER_ARGF2 JITTER_ARGP2

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of one-plus-register/%rR/%rR/fR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "one-plus-register/%rR/%rR/fR"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for one-plus-register/%rR/%rR/fR . */
  {
/* User-specified code, user code block part: beginning. */

#if ! defined (JITTERLISP_UNSAFE)
    JITTERLISP_BRANCH_FAST_UNLESS_FIXNUM (JITTER_ARG0, JITTER_ARGF2);
#endif
    JITTERLISP_1PLUS_OR_OVERFLOW_(JITTER_ARG1,
                                  JITTER_ARG0,
                                  JITTER_ARGF2);
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for one-plus-register/%rR/%rR/fR . */

  //fprintf (stderr, "..Executed instruction %s\n", "one-plus-register/%rR/%rR/fR");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the one-plus-register/%rR/%rR/fR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1
#   undef JITTER_SLOW_REGISTER_OFFSET2
#   undef JITTER_ARG2
#   undef JITTER_ARGN2
#   undef JITTER_ARGU2
#   undef JITTER_ARGP2
#   undef JITTER_ARGF2

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(one-plus-register/%rR/%rR/fR, one_mplus_mregister___rrR___rrR__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for one-plus-register/%rR/%rR/fR, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction pop-to-global/nR/fR */
  JITTER_INSTRUCTION_PROLOG_(pop-to-global/nR/fR, pop_mto_mglobal__nR__fR, cold)
  { /* This block begins with definitions for pop-to-global/nR/fR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       123
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         pop-to-global/nR/fR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "pop-to-global"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "pop-to-global/nR/fR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME pop_mto_mglobal__nR__fR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity varies depending on whether we have fast labels. */
#ifdef JITTER_HAVE_PATCH_IN
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
#else
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 2
#endif // #ifdef JITTER_HAVE_PATCH_IN

  /* Define argument-access macros for pop-to-global/nR/fR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a residual literal. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)

    /* The 1th argument is a "residual" fast label.  Define its
       _ARGF macro as the residual *index* (counting only fast labels, 0-based),
       so that at replication time we know what instruction address to patch in. */
#   define JITTER_ARGF1 0
    /* JITTER_ARG1 is intentionally not defined for a fast label. */

#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
    /* The 0th argument is a residual literal. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of pop-to-global/nR/fR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "pop-to-global/nR/fR"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for pop-to-global/nR/fR . */
  {
/* User-specified code, user code block part: beginning. */

    jitterlisp_object tagged_symbol = JITTER_ARGN0;
    struct jitterlisp_symbol *symbol = JITTERLISP_SYMBOL_DECODE(tagged_symbol);
#ifndef JITTERLISP_UNSAFE
    JITTER_BRANCH_FAST_IF_NONZERO (symbol->global_constant, JITTER_ARGF1);
#endif // #ifndef JITTERLISP_UNSAFE
    symbol->global_value = JITTER_TOP_MAINSTACK();
    JITTER_DROP_MAINSTACK();
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for pop-to-global/nR/fR . */

  //fprintf (stderr, "..Executed instruction %s\n", "pop-to-global/nR/fR");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the pop-to-global/nR/fR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(pop-to-global/nR/fR, pop_mto_mglobal__nR__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for pop-to-global/nR/fR, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction pop-to-global-defined/nR/fR */
  JITTER_INSTRUCTION_PROLOG_(pop-to-global-defined/nR/fR, pop_mto_mglobal_mdefined__nR__fR, cold)
  { /* This block begins with definitions for pop-to-global-defined/nR/fR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       124
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         pop-to-global-defined/nR/fR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "pop-to-global-defined"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "pop-to-global-defined/nR/fR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME pop_mto_mglobal_mdefined__nR__fR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity varies depending on whether we have fast labels. */
#ifdef JITTER_HAVE_PATCH_IN
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
#else
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 2
#endif // #ifdef JITTER_HAVE_PATCH_IN

  /* Define argument-access macros for pop-to-global-defined/nR/fR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a residual literal. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)

    /* The 1th argument is a "residual" fast label.  Define its
       _ARGF macro as the residual *index* (counting only fast labels, 0-based),
       so that at replication time we know what instruction address to patch in. */
#   define JITTER_ARGF1 0
    /* JITTER_ARG1 is intentionally not defined for a fast label. */

#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
    /* The 0th argument is a residual literal. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of pop-to-global-defined/nR/fR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "pop-to-global-defined/nR/fR"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for pop-to-global-defined/nR/fR . */
  {
/* User-specified code, user code block part: beginning. */

    jitterlisp_object tagged_symbol = JITTER_ARGN0;
    struct jitterlisp_symbol *symbol = JITTERLISP_SYMBOL_DECODE(tagged_symbol);
#ifndef JITTERLISP_UNSAFE
    JITTER_BRANCH_FAST_IF_NONZERO (symbol->global_constant, JITTER_ARGF1);
    JITTER_BRANCH_FAST_IF_EQUAL (symbol->global_value, JITTERLISP_UNDEFINED,
                                 JITTER_ARGF1);
#endif // #ifndef JITTERLISP_UNSAFE
    symbol->global_value = JITTER_TOP_MAINSTACK();
    JITTER_DROP_MAINSTACK();
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for pop-to-global-defined/nR/fR . */

  //fprintf (stderr, "..Executed instruction %s\n", "pop-to-global-defined/nR/fR");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the pop-to-global-defined/nR/fR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(pop-to-global-defined/nR/fR, pop_mto_mglobal_mdefined__nR__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for pop-to-global-defined/nR/fR, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction pop-to-register/%rR */
  JITTER_INSTRUCTION_PROLOG_(pop-to-register/%rR, pop_mto_mregister___rrR, cold)
  { /* This block begins with definitions for pop-to-register/%rR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       125
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         pop-to-register/%rR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "pop-to-register"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "pop-to-register/%rR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME pop_mto_mregister___rrR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is not branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is not branching: undefine branch
       macros so that they cannot be used by mistake. */
/* Locally poison JITTER_COMPUTED_GOTO . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_COMPUTED_GOTO")
# undef JITTER_COMPUTED_GOTO
# define JITTER_COMPUTED_GOTO JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_COMPUTED_GOTO, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_COMPUTED_GOTO
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_COMPUTED_GOTO . */

/* Locally poison JITTER_BRANCH . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_BRANCH")
# undef JITTER_BRANCH
# define JITTER_BRANCH JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_BRANCH, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_BRANCH
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_BRANCH . */

/* Locally poison JITTER_EXIT . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_EXIT")
# undef JITTER_EXIT
# define JITTER_EXIT JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_EXIT, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_EXIT
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_EXIT . */

  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1

    /* The 0th argument is a slow (therefore residual, passed as an offset)
        register. */
  /* Define a macro expanding to the slow register offset. */
#if defined(JITTER_DISPATCH_NO_THREADING)
# define JITTER_SLOW_REGISTER_OFFSET0 (JITTER_RESIDUAL_ARGUMENT_0.fixnum)
#elif defined (JITTER_DISPATCH_MINIMAL_THREADING)
# define JITTER_SLOW_REGISTER_OFFSET0 ((((union jitter_word*)jitter_ip)[0]).fixnum)
#else
# define JITTER_SLOW_REGISTER_OFFSET0 ((((union jitter_word*)jitter_ip)[1]).fixnum)
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
  /* Define a macro expanding to an l-value for the VM register content. */
#   define JITTER_ARG0  JITTER_SLOW_REGISTER_FROM_OFFSET(r, JITTER_SLOW_REGISTER_OFFSET0)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0


#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of pop-to-register/%rR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "pop-to-register/%rR"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for pop-to-register/%rR . */
  {
/* User-specified code, user code block part: beginning. */

    JITTER_ARG0 = JITTER_TOP_MAINSTACK();
    JITTER_DROP_MAINSTACK();
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for pop-to-register/%rR . */

  //fprintf (stderr, "..Executed instruction %s\n", "pop-to-register/%rR");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the pop-to-register/%rR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_EXIT")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_BRANCH")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_COMPUTED_GOTO")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(pop-to-register/%rR, pop_mto_mregister___rrR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for pop-to-register/%rR, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction primitive/nR/n0/fR */
  JITTER_INSTRUCTION_PROLOG_(primitive/nR/n0/fR, primitive__nR__n0__fR, cold)
  { /* This block begins with definitions for primitive/nR/n0/fR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       126
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         primitive/nR/n0/fR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "primitive"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "primitive/nR/n0/fR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME primitive__nR__n0__fR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity varies depending on whether we have fast labels. */
#ifdef JITTER_HAVE_PATCH_IN
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
#else
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 2
#endif // #ifdef JITTER_HAVE_PATCH_IN

  /* Define argument-access macros for primitive/nR/n0/fR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a residual literal. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)

    /* The 1th argument is a nonresidual literal. */
#   define JITTER_ARG1  ((const union jitter_word){.fixnum = 0L})
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)

    /* The 2th argument is a "residual" fast label.  Define its
       _ARGF macro as the residual *index* (counting only fast labels, 0-based),
       so that at replication time we know what instruction address to patch in. */
#   define JITTER_ARGF2 0
    /* JITTER_ARG2 is intentionally not defined for a fast label. */

#   define JITTER_ARGN2 (JITTER_ARG2.fixnum)
#   define JITTER_ARGU2 (JITTER_ARG2.ufixnum)
#   define JITTER_ARGP2 (JITTER_ARG2.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
    /* The 0th argument is a residual literal. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a nonresidual literal. */
#   define JITTER_ARG1  ((const union jitter_word){.fixnum = 0L})
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG2  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN2 (JITTER_ARG2.fixnum)
#   define JITTER_ARGU2 (JITTER_ARG2.ufixnum)
#   define JITTER_ARGP2 (JITTER_ARG2.pointer)
#   define JITTER_ARGF2 JITTER_ARGP2

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of primitive/nR/n0/fR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "primitive/nR/n0/fR"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for primitive/nR/n0/fR . */
  {
/* User-specified code, user code block part: beginning. */

    /* The error-handling label is not actually used in this case: the
       primitive function, written in C, has its own handling.  It's
       harmless to have it anyway, as it makes the C code generator
       more uniform. */
    jitterlisp_primitive_function p
      = (jitterlisp_primitive_function) JITTER_ARGP0;
    const jitter_uint in_arity = JITTER_ARGN1;
    JITTER_PUSH_UNSPECIFIED_MAINSTACK();
    //asm volatile ("nop");
    jitterlisp_object *first_arg
      // FIXME: add a stack operator to compute this address.
      = (& JITTER_UNDER_TOP_MAINSTACK()) - in_arity + 1;
    jitterlisp_object res = JITTER_CALL_C (p, first_arg);

    jitter_uint i;
    // Remove as many elements as the primitive in-arity, but not more:
    // the top unspecified value we pushed will be replaced with the result.
    for (i = 0; i < in_arity; i ++)
      JITTER_NIP_MAINSTACK();
    //asm ("unop" : "+g" (jitter_state_runtime));
    JITTER_TOP_MAINSTACK() = res;
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for primitive/nR/n0/fR . */

  //fprintf (stderr, "..Executed instruction %s\n", "primitive/nR/n0/fR");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the primitive/nR/n0/fR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1
#   undef JITTER_SLOW_REGISTER_OFFSET2
#   undef JITTER_ARG2
#   undef JITTER_ARGN2
#   undef JITTER_ARGU2
#   undef JITTER_ARGP2
#   undef JITTER_ARGF2

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(primitive/nR/n0/fR, primitive__nR__n0__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for primitive/nR/n0/fR, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction primitive/nR/n1/fR */
  JITTER_INSTRUCTION_PROLOG_(primitive/nR/n1/fR, primitive__nR__n1__fR, cold)
  { /* This block begins with definitions for primitive/nR/n1/fR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       127
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         primitive/nR/n1/fR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "primitive"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "primitive/nR/n1/fR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME primitive__nR__n1__fR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity varies depending on whether we have fast labels. */
#ifdef JITTER_HAVE_PATCH_IN
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
#else
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 2
#endif // #ifdef JITTER_HAVE_PATCH_IN

  /* Define argument-access macros for primitive/nR/n1/fR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a residual literal. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)

    /* The 1th argument is a nonresidual literal. */
#   define JITTER_ARG1  ((const union jitter_word){.fixnum = 1L})
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)

    /* The 2th argument is a "residual" fast label.  Define its
       _ARGF macro as the residual *index* (counting only fast labels, 0-based),
       so that at replication time we know what instruction address to patch in. */
#   define JITTER_ARGF2 0
    /* JITTER_ARG2 is intentionally not defined for a fast label. */

#   define JITTER_ARGN2 (JITTER_ARG2.fixnum)
#   define JITTER_ARGU2 (JITTER_ARG2.ufixnum)
#   define JITTER_ARGP2 (JITTER_ARG2.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
    /* The 0th argument is a residual literal. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a nonresidual literal. */
#   define JITTER_ARG1  ((const union jitter_word){.fixnum = 1L})
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG2  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN2 (JITTER_ARG2.fixnum)
#   define JITTER_ARGU2 (JITTER_ARG2.ufixnum)
#   define JITTER_ARGP2 (JITTER_ARG2.pointer)
#   define JITTER_ARGF2 JITTER_ARGP2

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of primitive/nR/n1/fR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "primitive/nR/n1/fR"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for primitive/nR/n1/fR . */
  {
/* User-specified code, user code block part: beginning. */

    /* The error-handling label is not actually used in this case: the
       primitive function, written in C, has its own handling.  It's
       harmless to have it anyway, as it makes the C code generator
       more uniform. */
    jitterlisp_primitive_function p
      = (jitterlisp_primitive_function) JITTER_ARGP0;
    const jitter_uint in_arity = JITTER_ARGN1;
    JITTER_PUSH_UNSPECIFIED_MAINSTACK();
    //asm volatile ("nop");
    jitterlisp_object *first_arg
      // FIXME: add a stack operator to compute this address.
      = (& JITTER_UNDER_TOP_MAINSTACK()) - in_arity + 1;
    jitterlisp_object res = JITTER_CALL_C (p, first_arg);

    jitter_uint i;
    // Remove as many elements as the primitive in-arity, but not more:
    // the top unspecified value we pushed will be replaced with the result.
    for (i = 0; i < in_arity; i ++)
      JITTER_NIP_MAINSTACK();
    //asm ("unop" : "+g" (jitter_state_runtime));
    JITTER_TOP_MAINSTACK() = res;
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for primitive/nR/n1/fR . */

  //fprintf (stderr, "..Executed instruction %s\n", "primitive/nR/n1/fR");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the primitive/nR/n1/fR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1
#   undef JITTER_SLOW_REGISTER_OFFSET2
#   undef JITTER_ARG2
#   undef JITTER_ARGN2
#   undef JITTER_ARGU2
#   undef JITTER_ARGP2
#   undef JITTER_ARGF2

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(primitive/nR/n1/fR, primitive__nR__n1__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for primitive/nR/n1/fR, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction primitive/nR/n2/fR */
  JITTER_INSTRUCTION_PROLOG_(primitive/nR/n2/fR, primitive__nR__n2__fR, cold)
  { /* This block begins with definitions for primitive/nR/n2/fR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       128
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         primitive/nR/n2/fR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "primitive"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "primitive/nR/n2/fR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME primitive__nR__n2__fR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity varies depending on whether we have fast labels. */
#ifdef JITTER_HAVE_PATCH_IN
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
#else
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 2
#endif // #ifdef JITTER_HAVE_PATCH_IN

  /* Define argument-access macros for primitive/nR/n2/fR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a residual literal. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)

    /* The 1th argument is a nonresidual literal. */
#   define JITTER_ARG1  ((const union jitter_word){.fixnum = 2L})
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)

    /* The 2th argument is a "residual" fast label.  Define its
       _ARGF macro as the residual *index* (counting only fast labels, 0-based),
       so that at replication time we know what instruction address to patch in. */
#   define JITTER_ARGF2 0
    /* JITTER_ARG2 is intentionally not defined for a fast label. */

#   define JITTER_ARGN2 (JITTER_ARG2.fixnum)
#   define JITTER_ARGU2 (JITTER_ARG2.ufixnum)
#   define JITTER_ARGP2 (JITTER_ARG2.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
    /* The 0th argument is a residual literal. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a nonresidual literal. */
#   define JITTER_ARG1  ((const union jitter_word){.fixnum = 2L})
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG2  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN2 (JITTER_ARG2.fixnum)
#   define JITTER_ARGU2 (JITTER_ARG2.ufixnum)
#   define JITTER_ARGP2 (JITTER_ARG2.pointer)
#   define JITTER_ARGF2 JITTER_ARGP2

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of primitive/nR/n2/fR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "primitive/nR/n2/fR"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for primitive/nR/n2/fR . */
  {
/* User-specified code, user code block part: beginning. */

    /* The error-handling label is not actually used in this case: the
       primitive function, written in C, has its own handling.  It's
       harmless to have it anyway, as it makes the C code generator
       more uniform. */
    jitterlisp_primitive_function p
      = (jitterlisp_primitive_function) JITTER_ARGP0;
    const jitter_uint in_arity = JITTER_ARGN1;
    JITTER_PUSH_UNSPECIFIED_MAINSTACK();
    //asm volatile ("nop");
    jitterlisp_object *first_arg
      // FIXME: add a stack operator to compute this address.
      = (& JITTER_UNDER_TOP_MAINSTACK()) - in_arity + 1;
    jitterlisp_object res = JITTER_CALL_C (p, first_arg);

    jitter_uint i;
    // Remove as many elements as the primitive in-arity, but not more:
    // the top unspecified value we pushed will be replaced with the result.
    for (i = 0; i < in_arity; i ++)
      JITTER_NIP_MAINSTACK();
    //asm ("unop" : "+g" (jitter_state_runtime));
    JITTER_TOP_MAINSTACK() = res;
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for primitive/nR/n2/fR . */

  //fprintf (stderr, "..Executed instruction %s\n", "primitive/nR/n2/fR");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the primitive/nR/n2/fR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1
#   undef JITTER_SLOW_REGISTER_OFFSET2
#   undef JITTER_ARG2
#   undef JITTER_ARGN2
#   undef JITTER_ARGU2
#   undef JITTER_ARGP2
#   undef JITTER_ARGF2

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(primitive/nR/n2/fR, primitive__nR__n2__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for primitive/nR/n2/fR, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction primitive/nR/n3/fR */
  JITTER_INSTRUCTION_PROLOG_(primitive/nR/n3/fR, primitive__nR__n3__fR, cold)
  { /* This block begins with definitions for primitive/nR/n3/fR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       129
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         primitive/nR/n3/fR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "primitive"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "primitive/nR/n3/fR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME primitive__nR__n3__fR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity varies depending on whether we have fast labels. */
#ifdef JITTER_HAVE_PATCH_IN
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
#else
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 2
#endif // #ifdef JITTER_HAVE_PATCH_IN

  /* Define argument-access macros for primitive/nR/n3/fR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a residual literal. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)

    /* The 1th argument is a nonresidual literal. */
#   define JITTER_ARG1  ((const union jitter_word){.fixnum = 3L})
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)

    /* The 2th argument is a "residual" fast label.  Define its
       _ARGF macro as the residual *index* (counting only fast labels, 0-based),
       so that at replication time we know what instruction address to patch in. */
#   define JITTER_ARGF2 0
    /* JITTER_ARG2 is intentionally not defined for a fast label. */

#   define JITTER_ARGN2 (JITTER_ARG2.fixnum)
#   define JITTER_ARGU2 (JITTER_ARG2.ufixnum)
#   define JITTER_ARGP2 (JITTER_ARG2.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
    /* The 0th argument is a residual literal. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a nonresidual literal. */
#   define JITTER_ARG1  ((const union jitter_word){.fixnum = 3L})
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG2  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN2 (JITTER_ARG2.fixnum)
#   define JITTER_ARGU2 (JITTER_ARG2.ufixnum)
#   define JITTER_ARGP2 (JITTER_ARG2.pointer)
#   define JITTER_ARGF2 JITTER_ARGP2

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of primitive/nR/n3/fR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "primitive/nR/n3/fR"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for primitive/nR/n3/fR . */
  {
/* User-specified code, user code block part: beginning. */

    /* The error-handling label is not actually used in this case: the
       primitive function, written in C, has its own handling.  It's
       harmless to have it anyway, as it makes the C code generator
       more uniform. */
    jitterlisp_primitive_function p
      = (jitterlisp_primitive_function) JITTER_ARGP0;
    const jitter_uint in_arity = JITTER_ARGN1;
    JITTER_PUSH_UNSPECIFIED_MAINSTACK();
    //asm volatile ("nop");
    jitterlisp_object *first_arg
      // FIXME: add a stack operator to compute this address.
      = (& JITTER_UNDER_TOP_MAINSTACK()) - in_arity + 1;
    jitterlisp_object res = JITTER_CALL_C (p, first_arg);

    jitter_uint i;
    // Remove as many elements as the primitive in-arity, but not more:
    // the top unspecified value we pushed will be replaced with the result.
    for (i = 0; i < in_arity; i ++)
      JITTER_NIP_MAINSTACK();
    //asm ("unop" : "+g" (jitter_state_runtime));
    JITTER_TOP_MAINSTACK() = res;
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for primitive/nR/n3/fR . */

  //fprintf (stderr, "..Executed instruction %s\n", "primitive/nR/n3/fR");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the primitive/nR/n3/fR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1
#   undef JITTER_SLOW_REGISTER_OFFSET2
#   undef JITTER_ARG2
#   undef JITTER_ARGN2
#   undef JITTER_ARGU2
#   undef JITTER_ARGP2
#   undef JITTER_ARGF2

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(primitive/nR/n3/fR, primitive__nR__n3__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for primitive/nR/n3/fR, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction primitive/nR/n4/fR */
  JITTER_INSTRUCTION_PROLOG_(primitive/nR/n4/fR, primitive__nR__n4__fR, cold)
  { /* This block begins with definitions for primitive/nR/n4/fR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       130
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         primitive/nR/n4/fR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "primitive"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "primitive/nR/n4/fR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME primitive__nR__n4__fR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity varies depending on whether we have fast labels. */
#ifdef JITTER_HAVE_PATCH_IN
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
#else
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 2
#endif // #ifdef JITTER_HAVE_PATCH_IN

  /* Define argument-access macros for primitive/nR/n4/fR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a residual literal. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)

    /* The 1th argument is a nonresidual literal. */
#   define JITTER_ARG1  ((const union jitter_word){.fixnum = 4L})
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)

    /* The 2th argument is a "residual" fast label.  Define its
       _ARGF macro as the residual *index* (counting only fast labels, 0-based),
       so that at replication time we know what instruction address to patch in. */
#   define JITTER_ARGF2 0
    /* JITTER_ARG2 is intentionally not defined for a fast label. */

#   define JITTER_ARGN2 (JITTER_ARG2.fixnum)
#   define JITTER_ARGU2 (JITTER_ARG2.ufixnum)
#   define JITTER_ARGP2 (JITTER_ARG2.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
    /* The 0th argument is a residual literal. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a nonresidual literal. */
#   define JITTER_ARG1  ((const union jitter_word){.fixnum = 4L})
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG2  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN2 (JITTER_ARG2.fixnum)
#   define JITTER_ARGU2 (JITTER_ARG2.ufixnum)
#   define JITTER_ARGP2 (JITTER_ARG2.pointer)
#   define JITTER_ARGF2 JITTER_ARGP2

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of primitive/nR/n4/fR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "primitive/nR/n4/fR"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for primitive/nR/n4/fR . */
  {
/* User-specified code, user code block part: beginning. */

    /* The error-handling label is not actually used in this case: the
       primitive function, written in C, has its own handling.  It's
       harmless to have it anyway, as it makes the C code generator
       more uniform. */
    jitterlisp_primitive_function p
      = (jitterlisp_primitive_function) JITTER_ARGP0;
    const jitter_uint in_arity = JITTER_ARGN1;
    JITTER_PUSH_UNSPECIFIED_MAINSTACK();
    //asm volatile ("nop");
    jitterlisp_object *first_arg
      // FIXME: add a stack operator to compute this address.
      = (& JITTER_UNDER_TOP_MAINSTACK()) - in_arity + 1;
    jitterlisp_object res = JITTER_CALL_C (p, first_arg);

    jitter_uint i;
    // Remove as many elements as the primitive in-arity, but not more:
    // the top unspecified value we pushed will be replaced with the result.
    for (i = 0; i < in_arity; i ++)
      JITTER_NIP_MAINSTACK();
    //asm ("unop" : "+g" (jitter_state_runtime));
    JITTER_TOP_MAINSTACK() = res;
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for primitive/nR/n4/fR . */

  //fprintf (stderr, "..Executed instruction %s\n", "primitive/nR/n4/fR");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the primitive/nR/n4/fR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1
#   undef JITTER_SLOW_REGISTER_OFFSET2
#   undef JITTER_ARG2
#   undef JITTER_ARGN2
#   undef JITTER_ARGU2
#   undef JITTER_ARGP2
#   undef JITTER_ARGF2

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(primitive/nR/n4/fR, primitive__nR__n4__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for primitive/nR/n4/fR, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction primitive/nR/nR/fR */
  JITTER_INSTRUCTION_PROLOG_(primitive/nR/nR/fR, primitive__nR__nR__fR, cold)
  { /* This block begins with definitions for primitive/nR/nR/fR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       131
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         primitive/nR/nR/fR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "primitive"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "primitive/nR/nR/fR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME primitive__nR__nR__fR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity varies depending on whether we have fast labels. */
#ifdef JITTER_HAVE_PATCH_IN
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 2
#else
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 3
#endif // #ifdef JITTER_HAVE_PATCH_IN

  /* Define argument-access macros for primitive/nR/nR/fR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a residual literal. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)

    /* The 1th argument is a residual literal. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)

    /* The 2th argument is a "residual" fast label.  Define its
       _ARGF macro as the residual *index* (counting only fast labels, 0-based),
       so that at replication time we know what instruction address to patch in. */
#   define JITTER_ARGF2 0
    /* JITTER_ARG2 is intentionally not defined for a fast label. */

#   define JITTER_ARGN2 (JITTER_ARG2.fixnum)
#   define JITTER_ARGU2 (JITTER_ARG2.ufixnum)
#   define JITTER_ARGP2 (JITTER_ARG2.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
    /* The 0th argument is a residual literal. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual literal. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG2  JITTER_RESIDUAL_ARGUMENT_2
    JITTER_MARK_RESIDUAL_2_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[2])
#else
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[3])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN2 (JITTER_ARG2.fixnum)
#   define JITTER_ARGU2 (JITTER_ARG2.ufixnum)
#   define JITTER_ARGP2 (JITTER_ARG2.pointer)
#   define JITTER_ARGF2 JITTER_ARGP2

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of primitive/nR/nR/fR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "primitive/nR/nR/fR"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for primitive/nR/nR/fR . */
  {
/* User-specified code, user code block part: beginning. */

    /* The error-handling label is not actually used in this case: the
       primitive function, written in C, has its own handling.  It's
       harmless to have it anyway, as it makes the C code generator
       more uniform. */
    jitterlisp_primitive_function p
      = (jitterlisp_primitive_function) JITTER_ARGP0;
    const jitter_uint in_arity = JITTER_ARGN1;
    JITTER_PUSH_UNSPECIFIED_MAINSTACK();
    //asm volatile ("nop");
    jitterlisp_object *first_arg
      // FIXME: add a stack operator to compute this address.
      = (& JITTER_UNDER_TOP_MAINSTACK()) - in_arity + 1;
    jitterlisp_object res = JITTER_CALL_C (p, first_arg);

    jitter_uint i;
    // Remove as many elements as the primitive in-arity, but not more:
    // the top unspecified value we pushed will be replaced with the result.
    for (i = 0; i < in_arity; i ++)
      JITTER_NIP_MAINSTACK();
    //asm ("unop" : "+g" (jitter_state_runtime));
    JITTER_TOP_MAINSTACK() = res;
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for primitive/nR/nR/fR . */

  //fprintf (stderr, "..Executed instruction %s\n", "primitive/nR/nR/fR");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the primitive/nR/nR/fR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1
#   undef JITTER_SLOW_REGISTER_OFFSET2
#   undef JITTER_ARG2
#   undef JITTER_ARGN2
#   undef JITTER_ARGU2
#   undef JITTER_ARGP2
#   undef JITTER_ARGF2

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(primitive/nR/nR/fR, primitive__nR__nR__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for primitive/nR/nR/fR, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction primitive-boolean-canonicalize */
  JITTER_INSTRUCTION_PROLOG_(primitive-boolean-canonicalize, primitive_mboolean_mcanonicalize, hot)
  { /* This block begins with definitions for primitive-boolean-canonicalize . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       132
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         primitive-boolean-canonicalize
#   define JITTER_INSTRUCTION_NAME_AS_STRING "primitive-boolean-canonicalize"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "primitive-boolean-canonicalize"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME primitive_mboolean_mcanonicalize

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is not branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is not branching: undefine branch
       macros so that they cannot be used by mistake. */
/* Locally poison JITTER_COMPUTED_GOTO . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_COMPUTED_GOTO")
# undef JITTER_COMPUTED_GOTO
# define JITTER_COMPUTED_GOTO JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_COMPUTED_GOTO, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_COMPUTED_GOTO
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_COMPUTED_GOTO . */

/* Locally poison JITTER_BRANCH . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_BRANCH")
# undef JITTER_BRANCH
# define JITTER_BRANCH JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_BRANCH, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_BRANCH
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_BRANCH . */

/* Locally poison JITTER_EXIT . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_EXIT")
# undef JITTER_EXIT
# define JITTER_EXIT JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_EXIT, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_EXIT
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_EXIT . */

  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0


#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of primitive-boolean-canonicalize ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "primitive-boolean-canonicalize"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for primitive-boolean-canonicalize . */
  {
/* User-specified code, user code block part: beginning. */

    JITTERLISP_BOOLEAN_CANONICALIZE_(JITTER_TOP_MAINSTACK(),
                                     JITTER_TOP_MAINSTACK());
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for primitive-boolean-canonicalize . */

  //fprintf (stderr, "..Executed instruction %s\n", "primitive-boolean-canonicalize");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the primitive-boolean-canonicalize argument macros so they can't be used
       by mistake in the instruction body coming next. */

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_EXIT")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_BRANCH")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_COMPUTED_GOTO")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(primitive-boolean-canonicalize, primitive_mboolean_mcanonicalize, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for primitive-boolean-canonicalize, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction primitive-box */
  JITTER_INSTRUCTION_PROLOG_(primitive-box, primitive_mbox, hot)
  { /* This block begins with definitions for primitive-box . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       133
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         primitive-box
#   define JITTER_INSTRUCTION_NAME_AS_STRING "primitive-box"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "primitive-box"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME primitive_mbox

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is not branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is not branching: undefine branch
       macros so that they cannot be used by mistake. */
/* Locally poison JITTER_COMPUTED_GOTO . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_COMPUTED_GOTO")
# undef JITTER_COMPUTED_GOTO
# define JITTER_COMPUTED_GOTO JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_COMPUTED_GOTO, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_COMPUTED_GOTO
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_COMPUTED_GOTO . */

/* Locally poison JITTER_BRANCH . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_BRANCH")
# undef JITTER_BRANCH
# define JITTER_BRANCH JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_BRANCH, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_BRANCH
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_BRANCH . */

/* Locally poison JITTER_EXIT . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_EXIT")
# undef JITTER_EXIT
# define JITTER_EXIT JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_EXIT, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_EXIT
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_EXIT . */

  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0


#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of primitive-box ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "primitive-box"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for primitive-box . */
  {
/* User-specified code, user code block part: beginning. */

    JITTERLISP_BOX_(JITTER_TOP_MAINSTACK(), JITTER_TOP_MAINSTACK());
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for primitive-box . */

  //fprintf (stderr, "..Executed instruction %s\n", "primitive-box");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the primitive-box argument macros so they can't be used
       by mistake in the instruction body coming next. */

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_EXIT")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_BRANCH")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_COMPUTED_GOTO")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(primitive-box, primitive_mbox, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for primitive-box, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction primitive-box-get/fR */
  JITTER_INSTRUCTION_PROLOG_(primitive-box-get/fR, primitive_mbox_mget__fR, hot)
  { /* This block begins with definitions for primitive-box-get/fR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       134
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         primitive-box-get/fR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "primitive-box-get"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "primitive-box-get/fR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME primitive_mbox_mget__fR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity varies depending on whether we have fast labels. */
#ifdef JITTER_HAVE_PATCH_IN
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
#else
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
#endif // #ifdef JITTER_HAVE_PATCH_IN

  /* Define argument-access macros for primitive-box-get/fR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a "residual" fast label.  Define its
       _ARGF macro as the residual *index* (counting only fast labels, 0-based),
       so that at replication time we know what instruction address to patch in. */
#   define JITTER_ARGF0 0
    /* JITTER_ARG0 is intentionally not defined for a fast label. */

#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of primitive-box-get/fR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "primitive-box-get/fR"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for primitive-box-get/fR . */
  {
/* User-specified code, user code block part: beginning. */

    JITTERLISPVM_CHECK_TYPES_1(BOX, JITTER_ARGF0);
    JITTERLISP_BOX_GET_(JITTER_TOP_MAINSTACK(), JITTER_TOP_MAINSTACK());
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for primitive-box-get/fR . */

  //fprintf (stderr, "..Executed instruction %s\n", "primitive-box-get/fR");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the primitive-box-get/fR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(primitive-box-get/fR, primitive_mbox_mget__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for primitive-box-get/fR, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction primitive-box-setb-special/fR */
  JITTER_INSTRUCTION_PROLOG_(primitive-box-setb-special/fR, primitive_mbox_msetb_mspecial__fR, hot)
  { /* This block begins with definitions for primitive-box-setb-special/fR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       135
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         primitive-box-setb-special/fR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "primitive-box-setb-special"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "primitive-box-setb-special/fR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME primitive_mbox_msetb_mspecial__fR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity varies depending on whether we have fast labels. */
#ifdef JITTER_HAVE_PATCH_IN
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
#else
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
#endif // #ifdef JITTER_HAVE_PATCH_IN

  /* Define argument-access macros for primitive-box-setb-special/fR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a "residual" fast label.  Define its
       _ARGF macro as the residual *index* (counting only fast labels, 0-based),
       so that at replication time we know what instruction address to patch in. */
#   define JITTER_ARGF0 0
    /* JITTER_ARG0 is intentionally not defined for a fast label. */

#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of primitive-box-setb-special/fR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "primitive-box-setb-special/fR"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for primitive-box-setb-special/fR . */
  {
/* User-specified code, user code block part: beginning. */

    JITTERLISPVM_CHECK_TYPES_2(BOX, ANYTHING, JITTER_ARGF0);
    jitterlisp_object useless __attribute__ ((unused));
    JITTERLISP_BOX_SETB_(useless,
                         JITTER_UNDER_TOP_MAINSTACK(), JITTER_TOP_MAINSTACK());
    /* Leave the two operands on the stack. */
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for primitive-box-setb-special/fR . */

  //fprintf (stderr, "..Executed instruction %s\n", "primitive-box-setb-special/fR");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the primitive-box-setb-special/fR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(primitive-box-setb-special/fR, primitive_mbox_msetb_mspecial__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for primitive-box-setb-special/fR, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction primitive-car/fR */
  JITTER_INSTRUCTION_PROLOG_(primitive-car/fR, primitive_mcar__fR, hot)
  { /* This block begins with definitions for primitive-car/fR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       136
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         primitive-car/fR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "primitive-car"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "primitive-car/fR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME primitive_mcar__fR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity varies depending on whether we have fast labels. */
#ifdef JITTER_HAVE_PATCH_IN
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
#else
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
#endif // #ifdef JITTER_HAVE_PATCH_IN

  /* Define argument-access macros for primitive-car/fR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a "residual" fast label.  Define its
       _ARGF macro as the residual *index* (counting only fast labels, 0-based),
       so that at replication time we know what instruction address to patch in. */
#   define JITTER_ARGF0 0
    /* JITTER_ARG0 is intentionally not defined for a fast label. */

#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of primitive-car/fR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "primitive-car/fR"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for primitive-car/fR . */
  {
/* User-specified code, user code block part: beginning. */

    JITTERLISPVM_CHECK_TYPES_1(CONS, JITTER_ARGF0);
    JITTERLISP_CAR_(JITTER_TOP_MAINSTACK(), JITTER_TOP_MAINSTACK());
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for primitive-car/fR . */

  //fprintf (stderr, "..Executed instruction %s\n", "primitive-car/fR");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the primitive-car/fR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(primitive-car/fR, primitive_mcar__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for primitive-car/fR, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction primitive-cdr/fR */
  JITTER_INSTRUCTION_PROLOG_(primitive-cdr/fR, primitive_mcdr__fR, hot)
  { /* This block begins with definitions for primitive-cdr/fR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       137
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         primitive-cdr/fR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "primitive-cdr"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "primitive-cdr/fR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME primitive_mcdr__fR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity varies depending on whether we have fast labels. */
#ifdef JITTER_HAVE_PATCH_IN
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
#else
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
#endif // #ifdef JITTER_HAVE_PATCH_IN

  /* Define argument-access macros for primitive-cdr/fR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a "residual" fast label.  Define its
       _ARGF macro as the residual *index* (counting only fast labels, 0-based),
       so that at replication time we know what instruction address to patch in. */
#   define JITTER_ARGF0 0
    /* JITTER_ARG0 is intentionally not defined for a fast label. */

#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of primitive-cdr/fR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "primitive-cdr/fR"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for primitive-cdr/fR . */
  {
/* User-specified code, user code block part: beginning. */

    JITTERLISPVM_CHECK_TYPES_1(CONS, JITTER_ARGF0);
    JITTERLISP_CDR_(JITTER_TOP_MAINSTACK(), JITTER_TOP_MAINSTACK());
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for primitive-cdr/fR . */

  //fprintf (stderr, "..Executed instruction %s\n", "primitive-cdr/fR");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the primitive-cdr/fR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(primitive-cdr/fR, primitive_mcdr__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for primitive-cdr/fR, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction primitive-characterp */
  JITTER_INSTRUCTION_PROLOG_(primitive-characterp, primitive_mcharacterp, hot)
  { /* This block begins with definitions for primitive-characterp . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       138
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         primitive-characterp
#   define JITTER_INSTRUCTION_NAME_AS_STRING "primitive-characterp"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "primitive-characterp"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME primitive_mcharacterp

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is not branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is not branching: undefine branch
       macros so that they cannot be used by mistake. */
/* Locally poison JITTER_COMPUTED_GOTO . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_COMPUTED_GOTO")
# undef JITTER_COMPUTED_GOTO
# define JITTER_COMPUTED_GOTO JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_COMPUTED_GOTO, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_COMPUTED_GOTO
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_COMPUTED_GOTO . */

/* Locally poison JITTER_BRANCH . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_BRANCH")
# undef JITTER_BRANCH
# define JITTER_BRANCH JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_BRANCH, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_BRANCH
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_BRANCH . */

/* Locally poison JITTER_EXIT . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_EXIT")
# undef JITTER_EXIT
# define JITTER_EXIT JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_EXIT, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_EXIT
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_EXIT . */

  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0


#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of primitive-characterp ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "primitive-characterp"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for primitive-characterp . */
  {
/* User-specified code, user code block part: beginning. */

    JITTERLISP_CHARACTERP_(JITTER_TOP_MAINSTACK(), JITTER_TOP_MAINSTACK());
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for primitive-characterp . */

  //fprintf (stderr, "..Executed instruction %s\n", "primitive-characterp");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the primitive-characterp argument macros so they can't be used
       by mistake in the instruction body coming next. */

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_EXIT")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_BRANCH")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_COMPUTED_GOTO")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(primitive-characterp, primitive_mcharacterp, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for primitive-characterp, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction primitive-cons-special */
  JITTER_INSTRUCTION_PROLOG_(primitive-cons-special, primitive_mcons_mspecial, hot)
  { /* This block begins with definitions for primitive-cons-special . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       139
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         primitive-cons-special
#   define JITTER_INSTRUCTION_NAME_AS_STRING "primitive-cons-special"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "primitive-cons-special"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME primitive_mcons_mspecial

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is not branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is not branching: undefine branch
       macros so that they cannot be used by mistake. */
/* Locally poison JITTER_COMPUTED_GOTO . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_COMPUTED_GOTO")
# undef JITTER_COMPUTED_GOTO
# define JITTER_COMPUTED_GOTO JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_COMPUTED_GOTO, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_COMPUTED_GOTO
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_COMPUTED_GOTO . */

/* Locally poison JITTER_BRANCH . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_BRANCH")
# undef JITTER_BRANCH
# define JITTER_BRANCH JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_BRANCH, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_BRANCH
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_BRANCH . */

/* Locally poison JITTER_EXIT . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_EXIT")
# undef JITTER_EXIT
# define JITTER_EXIT JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_EXIT, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_EXIT
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_EXIT . */

  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0


#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of primitive-cons-special ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "primitive-cons-special"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for primitive-cons-special . */
  {
/* User-specified code, user code block part: beginning. */

#ifdef JITTER_GC_STUB
    /* This is a preliminary version of the allocation fast path, using a
       still non-existing Jitter garbage collector.
       Of course most of this should be factored into a macro. */
    const size_t allocation_size
      = JITTER_BYTES_PER_WORD * 2;
    const size_t header_size = 0;
    jitterlisp_object tagged_cons
      = JITTERLISP_CONS_ENCODE
          (JITTERLISPVM_STATE_RUNTIME_FIELD (allocation_next)
           - allocation_size + header_size);
    JITTERLISP_CONS_DECODE (tagged_cons)->car = JITTER_UNDER_TOP_MAINSTACK();
    JITTERLISP_CONS_DECODE (tagged_cons)->cdr = JITTER_TOP_MAINSTACK();
    JITTER_TOP_MAINSTACK() = tagged_cons;
#else // ! JITTER_GC_STUB
    JITTERLISP_CONS_(JITTER_TOP_MAINSTACK(),
                     JITTER_UNDER_TOP_MAINSTACK(), JITTER_TOP_MAINSTACK());
#endif //#ifdef JITTER_GC_STUB
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for primitive-cons-special . */

  //fprintf (stderr, "..Executed instruction %s\n", "primitive-cons-special");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the primitive-cons-special argument macros so they can't be used
       by mistake in the instruction body coming next. */

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_EXIT")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_BRANCH")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_COMPUTED_GOTO")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(primitive-cons-special, primitive_mcons_mspecial, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for primitive-cons-special, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction primitive-consp */
  JITTER_INSTRUCTION_PROLOG_(primitive-consp, primitive_mconsp, hot)
  { /* This block begins with definitions for primitive-consp . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       140
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         primitive-consp
#   define JITTER_INSTRUCTION_NAME_AS_STRING "primitive-consp"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "primitive-consp"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME primitive_mconsp

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is not branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is not branching: undefine branch
       macros so that they cannot be used by mistake. */
/* Locally poison JITTER_COMPUTED_GOTO . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_COMPUTED_GOTO")
# undef JITTER_COMPUTED_GOTO
# define JITTER_COMPUTED_GOTO JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_COMPUTED_GOTO, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_COMPUTED_GOTO
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_COMPUTED_GOTO . */

/* Locally poison JITTER_BRANCH . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_BRANCH")
# undef JITTER_BRANCH
# define JITTER_BRANCH JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_BRANCH, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_BRANCH
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_BRANCH . */

/* Locally poison JITTER_EXIT . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_EXIT")
# undef JITTER_EXIT
# define JITTER_EXIT JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_EXIT, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_EXIT
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_EXIT . */

  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0


#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of primitive-consp ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "primitive-consp"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for primitive-consp . */
  {
/* User-specified code, user code block part: beginning. */

    JITTERLISP_CONSP_(JITTER_TOP_MAINSTACK(), JITTER_TOP_MAINSTACK());
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for primitive-consp . */

  //fprintf (stderr, "..Executed instruction %s\n", "primitive-consp");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the primitive-consp argument macros so they can't be used
       by mistake in the instruction body coming next. */

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_EXIT")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_BRANCH")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_COMPUTED_GOTO")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(primitive-consp, primitive_mconsp, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for primitive-consp, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction primitive-eqp */
  JITTER_INSTRUCTION_PROLOG_(primitive-eqp, primitive_meqp, hot)
  { /* This block begins with definitions for primitive-eqp . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       141
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         primitive-eqp
#   define JITTER_INSTRUCTION_NAME_AS_STRING "primitive-eqp"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "primitive-eqp"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME primitive_meqp

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is not branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is not branching: undefine branch
       macros so that they cannot be used by mistake. */
/* Locally poison JITTER_COMPUTED_GOTO . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_COMPUTED_GOTO")
# undef JITTER_COMPUTED_GOTO
# define JITTER_COMPUTED_GOTO JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_COMPUTED_GOTO, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_COMPUTED_GOTO
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_COMPUTED_GOTO . */

/* Locally poison JITTER_BRANCH . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_BRANCH")
# undef JITTER_BRANCH
# define JITTER_BRANCH JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_BRANCH, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_BRANCH
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_BRANCH . */

/* Locally poison JITTER_EXIT . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_EXIT")
# undef JITTER_EXIT
# define JITTER_EXIT JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_EXIT, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_EXIT
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_EXIT . */

  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0


#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of primitive-eqp ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "primitive-eqp"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for primitive-eqp . */
  {
/* User-specified code, user code block part: beginning. */

    JITTERLISP_EQP_(JITTER_TOP_MAINSTACK(),
                    JITTER_UNDER_TOP_MAINSTACK(), JITTER_TOP_MAINSTACK());
    JITTER_NIP_MAINSTACK();
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for primitive-eqp . */

  //fprintf (stderr, "..Executed instruction %s\n", "primitive-eqp");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the primitive-eqp argument macros so they can't be used
       by mistake in the instruction body coming next. */

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_EXIT")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_BRANCH")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_COMPUTED_GOTO")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(primitive-eqp, primitive_meqp, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for primitive-eqp, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction primitive-fixnum-eqp/fR */
  JITTER_INSTRUCTION_PROLOG_(primitive-fixnum-eqp/fR, primitive_mfixnum_meqp__fR, hot)
  { /* This block begins with definitions for primitive-fixnum-eqp/fR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       142
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         primitive-fixnum-eqp/fR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "primitive-fixnum-eqp"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "primitive-fixnum-eqp/fR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME primitive_mfixnum_meqp__fR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity varies depending on whether we have fast labels. */
#ifdef JITTER_HAVE_PATCH_IN
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
#else
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
#endif // #ifdef JITTER_HAVE_PATCH_IN

  /* Define argument-access macros for primitive-fixnum-eqp/fR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a "residual" fast label.  Define its
       _ARGF macro as the residual *index* (counting only fast labels, 0-based),
       so that at replication time we know what instruction address to patch in. */
#   define JITTER_ARGF0 0
    /* JITTER_ARG0 is intentionally not defined for a fast label. */

#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of primitive-fixnum-eqp/fR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "primitive-fixnum-eqp/fR"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for primitive-fixnum-eqp/fR . */
  {
/* User-specified code, user code block part: beginning. */

    JITTERLISPVM_CHECK_TYPES_2(FIXNUM, FIXNUM, JITTER_ARGF0);
    JITTERLISP_EQP_(JITTER_TOP_MAINSTACK(),
                    JITTER_UNDER_TOP_MAINSTACK(), JITTER_TOP_MAINSTACK());
    JITTER_NIP_MAINSTACK();
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for primitive-fixnum-eqp/fR . */

  //fprintf (stderr, "..Executed instruction %s\n", "primitive-fixnum-eqp/fR");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the primitive-fixnum-eqp/fR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(primitive-fixnum-eqp/fR, primitive_mfixnum_meqp__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for primitive-fixnum-eqp/fR, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction primitive-fixnum-not-eqp/fR */
  JITTER_INSTRUCTION_PROLOG_(primitive-fixnum-not-eqp/fR, primitive_mfixnum_mnot_meqp__fR, hot)
  { /* This block begins with definitions for primitive-fixnum-not-eqp/fR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       143
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         primitive-fixnum-not-eqp/fR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "primitive-fixnum-not-eqp"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "primitive-fixnum-not-eqp/fR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME primitive_mfixnum_mnot_meqp__fR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity varies depending on whether we have fast labels. */
#ifdef JITTER_HAVE_PATCH_IN
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
#else
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
#endif // #ifdef JITTER_HAVE_PATCH_IN

  /* Define argument-access macros for primitive-fixnum-not-eqp/fR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a "residual" fast label.  Define its
       _ARGF macro as the residual *index* (counting only fast labels, 0-based),
       so that at replication time we know what instruction address to patch in. */
#   define JITTER_ARGF0 0
    /* JITTER_ARG0 is intentionally not defined for a fast label. */

#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of primitive-fixnum-not-eqp/fR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "primitive-fixnum-not-eqp/fR"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for primitive-fixnum-not-eqp/fR . */
  {
/* User-specified code, user code block part: beginning. */

    JITTERLISPVM_CHECK_TYPES_2(FIXNUM, FIXNUM, JITTER_ARGF0);
    JITTERLISP_NOT_EQP_(JITTER_TOP_MAINSTACK(),
                        JITTER_UNDER_TOP_MAINSTACK(), JITTER_TOP_MAINSTACK());
    JITTER_NIP_MAINSTACK();
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for primitive-fixnum-not-eqp/fR . */

  //fprintf (stderr, "..Executed instruction %s\n", "primitive-fixnum-not-eqp/fR");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the primitive-fixnum-not-eqp/fR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(primitive-fixnum-not-eqp/fR, primitive_mfixnum_mnot_meqp__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for primitive-fixnum-not-eqp/fR, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction primitive-fixnump */
  JITTER_INSTRUCTION_PROLOG_(primitive-fixnump, primitive_mfixnump, hot)
  { /* This block begins with definitions for primitive-fixnump . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       144
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         primitive-fixnump
#   define JITTER_INSTRUCTION_NAME_AS_STRING "primitive-fixnump"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "primitive-fixnump"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME primitive_mfixnump

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is not branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is not branching: undefine branch
       macros so that they cannot be used by mistake. */
/* Locally poison JITTER_COMPUTED_GOTO . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_COMPUTED_GOTO")
# undef JITTER_COMPUTED_GOTO
# define JITTER_COMPUTED_GOTO JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_COMPUTED_GOTO, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_COMPUTED_GOTO
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_COMPUTED_GOTO . */

/* Locally poison JITTER_BRANCH . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_BRANCH")
# undef JITTER_BRANCH
# define JITTER_BRANCH JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_BRANCH, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_BRANCH
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_BRANCH . */

/* Locally poison JITTER_EXIT . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_EXIT")
# undef JITTER_EXIT
# define JITTER_EXIT JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_EXIT, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_EXIT
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_EXIT . */

  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0


#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of primitive-fixnump ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "primitive-fixnump"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for primitive-fixnump . */
  {
/* User-specified code, user code block part: beginning. */

    JITTERLISP_FIXNUMP_(JITTER_TOP_MAINSTACK(), JITTER_TOP_MAINSTACK());
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for primitive-fixnump . */

  //fprintf (stderr, "..Executed instruction %s\n", "primitive-fixnump");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the primitive-fixnump argument macros so they can't be used
       by mistake in the instruction body coming next. */

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_EXIT")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_BRANCH")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_COMPUTED_GOTO")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(primitive-fixnump, primitive_mfixnump, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for primitive-fixnump, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction primitive-greaterp/fR */
  JITTER_INSTRUCTION_PROLOG_(primitive-greaterp/fR, primitive_mgreaterp__fR, hot)
  { /* This block begins with definitions for primitive-greaterp/fR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       145
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         primitive-greaterp/fR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "primitive-greaterp"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "primitive-greaterp/fR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME primitive_mgreaterp__fR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity varies depending on whether we have fast labels. */
#ifdef JITTER_HAVE_PATCH_IN
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
#else
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
#endif // #ifdef JITTER_HAVE_PATCH_IN

  /* Define argument-access macros for primitive-greaterp/fR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a "residual" fast label.  Define its
       _ARGF macro as the residual *index* (counting only fast labels, 0-based),
       so that at replication time we know what instruction address to patch in. */
#   define JITTER_ARGF0 0
    /* JITTER_ARG0 is intentionally not defined for a fast label. */

#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of primitive-greaterp/fR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "primitive-greaterp/fR"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for primitive-greaterp/fR . */
  {
/* User-specified code, user code block part: beginning. */

    JITTERLISPVM_CHECK_TYPES_2(FIXNUM, FIXNUM, JITTER_ARGF0);
    JITTERLISP_GREATERP_(JITTER_TOP_MAINSTACK(),
                         JITTER_UNDER_TOP_MAINSTACK(), JITTER_TOP_MAINSTACK());
    JITTER_NIP_MAINSTACK();
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for primitive-greaterp/fR . */

  //fprintf (stderr, "..Executed instruction %s\n", "primitive-greaterp/fR");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the primitive-greaterp/fR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(primitive-greaterp/fR, primitive_mgreaterp__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for primitive-greaterp/fR, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction primitive-lessp/fR */
  JITTER_INSTRUCTION_PROLOG_(primitive-lessp/fR, primitive_mlessp__fR, hot)
  { /* This block begins with definitions for primitive-lessp/fR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       146
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         primitive-lessp/fR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "primitive-lessp"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "primitive-lessp/fR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME primitive_mlessp__fR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity varies depending on whether we have fast labels. */
#ifdef JITTER_HAVE_PATCH_IN
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
#else
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
#endif // #ifdef JITTER_HAVE_PATCH_IN

  /* Define argument-access macros for primitive-lessp/fR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a "residual" fast label.  Define its
       _ARGF macro as the residual *index* (counting only fast labels, 0-based),
       so that at replication time we know what instruction address to patch in. */
#   define JITTER_ARGF0 0
    /* JITTER_ARG0 is intentionally not defined for a fast label. */

#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of primitive-lessp/fR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "primitive-lessp/fR"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for primitive-lessp/fR . */
  {
/* User-specified code, user code block part: beginning. */

    JITTERLISPVM_CHECK_TYPES_2(FIXNUM, FIXNUM, JITTER_ARGF0);
    JITTERLISP_LESSP_(JITTER_TOP_MAINSTACK(),
                      JITTER_UNDER_TOP_MAINSTACK(), JITTER_TOP_MAINSTACK());
    JITTER_NIP_MAINSTACK();
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for primitive-lessp/fR . */

  //fprintf (stderr, "..Executed instruction %s\n", "primitive-lessp/fR");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the primitive-lessp/fR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(primitive-lessp/fR, primitive_mlessp__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for primitive-lessp/fR, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction primitive-negate/fR */
  JITTER_INSTRUCTION_PROLOG_(primitive-negate/fR, primitive_mnegate__fR, hot)
  { /* This block begins with definitions for primitive-negate/fR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       147
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         primitive-negate/fR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "primitive-negate"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "primitive-negate/fR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME primitive_mnegate__fR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity varies depending on whether we have fast labels. */
#ifdef JITTER_HAVE_PATCH_IN
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
#else
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
#endif // #ifdef JITTER_HAVE_PATCH_IN

  /* Define argument-access macros for primitive-negate/fR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a "residual" fast label.  Define its
       _ARGF macro as the residual *index* (counting only fast labels, 0-based),
       so that at replication time we know what instruction address to patch in. */
#   define JITTER_ARGF0 0
    /* JITTER_ARG0 is intentionally not defined for a fast label. */

#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of primitive-negate/fR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "primitive-negate/fR"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for primitive-negate/fR . */
  {
/* User-specified code, user code block part: beginning. */

    JITTERLISPVM_CHECK_TYPES_1(FIXNUM, JITTER_ARGF0);
    JITTERLISP_NEGATE_OR_OVERFLOW_(JITTER_TOP_MAINSTACK(),
                                   JITTER_TOP_MAINSTACK(),
                                   JITTER_ARGF0);
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for primitive-negate/fR . */

  //fprintf (stderr, "..Executed instruction %s\n", "primitive-negate/fR");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the primitive-negate/fR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(primitive-negate/fR, primitive_mnegate__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for primitive-negate/fR, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction primitive-negativep/fR */
  JITTER_INSTRUCTION_PROLOG_(primitive-negativep/fR, primitive_mnegativep__fR, hot)
  { /* This block begins with definitions for primitive-negativep/fR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       148
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         primitive-negativep/fR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "primitive-negativep"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "primitive-negativep/fR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME primitive_mnegativep__fR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity varies depending on whether we have fast labels. */
#ifdef JITTER_HAVE_PATCH_IN
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
#else
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
#endif // #ifdef JITTER_HAVE_PATCH_IN

  /* Define argument-access macros for primitive-negativep/fR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a "residual" fast label.  Define its
       _ARGF macro as the residual *index* (counting only fast labels, 0-based),
       so that at replication time we know what instruction address to patch in. */
#   define JITTER_ARGF0 0
    /* JITTER_ARG0 is intentionally not defined for a fast label. */

#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of primitive-negativep/fR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "primitive-negativep/fR"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for primitive-negativep/fR . */
  {
/* User-specified code, user code block part: beginning. */

    JITTERLISPVM_CHECK_TYPES_1(FIXNUM, JITTER_ARGF0);
    JITTERLISP_NEGATIVEP_(JITTER_TOP_MAINSTACK(), JITTER_TOP_MAINSTACK());
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for primitive-negativep/fR . */

  //fprintf (stderr, "..Executed instruction %s\n", "primitive-negativep/fR");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the primitive-negativep/fR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(primitive-negativep/fR, primitive_mnegativep__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for primitive-negativep/fR, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction primitive-non-consp */
  JITTER_INSTRUCTION_PROLOG_(primitive-non-consp, primitive_mnon_mconsp, hot)
  { /* This block begins with definitions for primitive-non-consp . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       149
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         primitive-non-consp
#   define JITTER_INSTRUCTION_NAME_AS_STRING "primitive-non-consp"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "primitive-non-consp"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME primitive_mnon_mconsp

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is not branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is not branching: undefine branch
       macros so that they cannot be used by mistake. */
/* Locally poison JITTER_COMPUTED_GOTO . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_COMPUTED_GOTO")
# undef JITTER_COMPUTED_GOTO
# define JITTER_COMPUTED_GOTO JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_COMPUTED_GOTO, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_COMPUTED_GOTO
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_COMPUTED_GOTO . */

/* Locally poison JITTER_BRANCH . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_BRANCH")
# undef JITTER_BRANCH
# define JITTER_BRANCH JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_BRANCH, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_BRANCH
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_BRANCH . */

/* Locally poison JITTER_EXIT . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_EXIT")
# undef JITTER_EXIT
# define JITTER_EXIT JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_EXIT, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_EXIT
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_EXIT . */

  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0


#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of primitive-non-consp ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "primitive-non-consp"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for primitive-non-consp . */
  {
/* User-specified code, user code block part: beginning. */

    JITTERLISP_NON_CONSP_(JITTER_TOP_MAINSTACK(), JITTER_TOP_MAINSTACK());
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for primitive-non-consp . */

  //fprintf (stderr, "..Executed instruction %s\n", "primitive-non-consp");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the primitive-non-consp argument macros so they can't be used
       by mistake in the instruction body coming next. */

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_EXIT")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_BRANCH")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_COMPUTED_GOTO")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(primitive-non-consp, primitive_mnon_mconsp, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for primitive-non-consp, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction primitive-non-negativep/fR */
  JITTER_INSTRUCTION_PROLOG_(primitive-non-negativep/fR, primitive_mnon_mnegativep__fR, hot)
  { /* This block begins with definitions for primitive-non-negativep/fR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       150
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         primitive-non-negativep/fR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "primitive-non-negativep"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "primitive-non-negativep/fR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME primitive_mnon_mnegativep__fR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity varies depending on whether we have fast labels. */
#ifdef JITTER_HAVE_PATCH_IN
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
#else
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
#endif // #ifdef JITTER_HAVE_PATCH_IN

  /* Define argument-access macros for primitive-non-negativep/fR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a "residual" fast label.  Define its
       _ARGF macro as the residual *index* (counting only fast labels, 0-based),
       so that at replication time we know what instruction address to patch in. */
#   define JITTER_ARGF0 0
    /* JITTER_ARG0 is intentionally not defined for a fast label. */

#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of primitive-non-negativep/fR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "primitive-non-negativep/fR"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for primitive-non-negativep/fR . */
  {
/* User-specified code, user code block part: beginning. */

    JITTERLISPVM_CHECK_TYPES_1(FIXNUM, JITTER_ARGF0);
    JITTERLISP_NON_NEGATIVEP_(JITTER_TOP_MAINSTACK(), JITTER_TOP_MAINSTACK());
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for primitive-non-negativep/fR . */

  //fprintf (stderr, "..Executed instruction %s\n", "primitive-non-negativep/fR");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the primitive-non-negativep/fR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(primitive-non-negativep/fR, primitive_mnon_mnegativep__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for primitive-non-negativep/fR, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction primitive-non-nullp */
  JITTER_INSTRUCTION_PROLOG_(primitive-non-nullp, primitive_mnon_mnullp, hot)
  { /* This block begins with definitions for primitive-non-nullp . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       151
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         primitive-non-nullp
#   define JITTER_INSTRUCTION_NAME_AS_STRING "primitive-non-nullp"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "primitive-non-nullp"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME primitive_mnon_mnullp

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is not branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is not branching: undefine branch
       macros so that they cannot be used by mistake. */
/* Locally poison JITTER_COMPUTED_GOTO . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_COMPUTED_GOTO")
# undef JITTER_COMPUTED_GOTO
# define JITTER_COMPUTED_GOTO JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_COMPUTED_GOTO, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_COMPUTED_GOTO
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_COMPUTED_GOTO . */

/* Locally poison JITTER_BRANCH . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_BRANCH")
# undef JITTER_BRANCH
# define JITTER_BRANCH JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_BRANCH, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_BRANCH
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_BRANCH . */

/* Locally poison JITTER_EXIT . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_EXIT")
# undef JITTER_EXIT
# define JITTER_EXIT JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_EXIT, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_EXIT
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_EXIT . */

  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0


#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of primitive-non-nullp ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "primitive-non-nullp"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for primitive-non-nullp . */
  {
/* User-specified code, user code block part: beginning. */

    JITTERLISP_NON_NULLP_(JITTER_TOP_MAINSTACK(), JITTER_TOP_MAINSTACK());
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for primitive-non-nullp . */

  //fprintf (stderr, "..Executed instruction %s\n", "primitive-non-nullp");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the primitive-non-nullp argument macros so they can't be used
       by mistake in the instruction body coming next. */

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_EXIT")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_BRANCH")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_COMPUTED_GOTO")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(primitive-non-nullp, primitive_mnon_mnullp, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for primitive-non-nullp, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction primitive-non-positivep/fR */
  JITTER_INSTRUCTION_PROLOG_(primitive-non-positivep/fR, primitive_mnon_mpositivep__fR, hot)
  { /* This block begins with definitions for primitive-non-positivep/fR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       152
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         primitive-non-positivep/fR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "primitive-non-positivep"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "primitive-non-positivep/fR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME primitive_mnon_mpositivep__fR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity varies depending on whether we have fast labels. */
#ifdef JITTER_HAVE_PATCH_IN
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
#else
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
#endif // #ifdef JITTER_HAVE_PATCH_IN

  /* Define argument-access macros for primitive-non-positivep/fR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a "residual" fast label.  Define its
       _ARGF macro as the residual *index* (counting only fast labels, 0-based),
       so that at replication time we know what instruction address to patch in. */
#   define JITTER_ARGF0 0
    /* JITTER_ARG0 is intentionally not defined for a fast label. */

#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of primitive-non-positivep/fR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "primitive-non-positivep/fR"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for primitive-non-positivep/fR . */
  {
/* User-specified code, user code block part: beginning. */

    JITTERLISPVM_CHECK_TYPES_1(FIXNUM, JITTER_ARGF0);
    JITTERLISP_NON_POSITIVEP_(JITTER_TOP_MAINSTACK(), JITTER_TOP_MAINSTACK());
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for primitive-non-positivep/fR . */

  //fprintf (stderr, "..Executed instruction %s\n", "primitive-non-positivep/fR");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the primitive-non-positivep/fR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(primitive-non-positivep/fR, primitive_mnon_mpositivep__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for primitive-non-positivep/fR, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction primitive-non-symbolp */
  JITTER_INSTRUCTION_PROLOG_(primitive-non-symbolp, primitive_mnon_msymbolp, hot)
  { /* This block begins with definitions for primitive-non-symbolp . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       153
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         primitive-non-symbolp
#   define JITTER_INSTRUCTION_NAME_AS_STRING "primitive-non-symbolp"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "primitive-non-symbolp"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME primitive_mnon_msymbolp

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is not branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is not branching: undefine branch
       macros so that they cannot be used by mistake. */
/* Locally poison JITTER_COMPUTED_GOTO . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_COMPUTED_GOTO")
# undef JITTER_COMPUTED_GOTO
# define JITTER_COMPUTED_GOTO JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_COMPUTED_GOTO, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_COMPUTED_GOTO
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_COMPUTED_GOTO . */

/* Locally poison JITTER_BRANCH . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_BRANCH")
# undef JITTER_BRANCH
# define JITTER_BRANCH JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_BRANCH, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_BRANCH
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_BRANCH . */

/* Locally poison JITTER_EXIT . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_EXIT")
# undef JITTER_EXIT
# define JITTER_EXIT JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_EXIT, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_EXIT
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_EXIT . */

  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0


#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of primitive-non-symbolp ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "primitive-non-symbolp"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for primitive-non-symbolp . */
  {
/* User-specified code, user code block part: beginning. */

    JITTERLISP_NON_SYMBOLP_(JITTER_TOP_MAINSTACK(), JITTER_TOP_MAINSTACK());
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for primitive-non-symbolp . */

  //fprintf (stderr, "..Executed instruction %s\n", "primitive-non-symbolp");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the primitive-non-symbolp argument macros so they can't be used
       by mistake in the instruction body coming next. */

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_EXIT")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_BRANCH")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_COMPUTED_GOTO")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(primitive-non-symbolp, primitive_mnon_msymbolp, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for primitive-non-symbolp, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction primitive-non-zerop/fR */
  JITTER_INSTRUCTION_PROLOG_(primitive-non-zerop/fR, primitive_mnon_mzerop__fR, hot)
  { /* This block begins with definitions for primitive-non-zerop/fR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       154
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         primitive-non-zerop/fR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "primitive-non-zerop"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "primitive-non-zerop/fR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME primitive_mnon_mzerop__fR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity varies depending on whether we have fast labels. */
#ifdef JITTER_HAVE_PATCH_IN
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
#else
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
#endif // #ifdef JITTER_HAVE_PATCH_IN

  /* Define argument-access macros for primitive-non-zerop/fR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a "residual" fast label.  Define its
       _ARGF macro as the residual *index* (counting only fast labels, 0-based),
       so that at replication time we know what instruction address to patch in. */
#   define JITTER_ARGF0 0
    /* JITTER_ARG0 is intentionally not defined for a fast label. */

#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of primitive-non-zerop/fR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "primitive-non-zerop/fR"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for primitive-non-zerop/fR . */
  {
/* User-specified code, user code block part: beginning. */

    JITTERLISPVM_CHECK_TYPES_1(FIXNUM, JITTER_ARGF0);
    JITTERLISP_NON_ZEROP_(JITTER_TOP_MAINSTACK(), JITTER_TOP_MAINSTACK());
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for primitive-non-zerop/fR . */

  //fprintf (stderr, "..Executed instruction %s\n", "primitive-non-zerop/fR");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the primitive-non-zerop/fR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(primitive-non-zerop/fR, primitive_mnon_mzerop__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for primitive-non-zerop/fR, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction primitive-not */
  JITTER_INSTRUCTION_PROLOG_(primitive-not, primitive_mnot, hot)
  { /* This block begins with definitions for primitive-not . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       155
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         primitive-not
#   define JITTER_INSTRUCTION_NAME_AS_STRING "primitive-not"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "primitive-not"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME primitive_mnot

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is not branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is not branching: undefine branch
       macros so that they cannot be used by mistake. */
/* Locally poison JITTER_COMPUTED_GOTO . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_COMPUTED_GOTO")
# undef JITTER_COMPUTED_GOTO
# define JITTER_COMPUTED_GOTO JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_COMPUTED_GOTO, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_COMPUTED_GOTO
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_COMPUTED_GOTO . */

/* Locally poison JITTER_BRANCH . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_BRANCH")
# undef JITTER_BRANCH
# define JITTER_BRANCH JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_BRANCH, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_BRANCH
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_BRANCH . */

/* Locally poison JITTER_EXIT . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_EXIT")
# undef JITTER_EXIT
# define JITTER_EXIT JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_EXIT, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_EXIT
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_EXIT . */

  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0


#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of primitive-not ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "primitive-not"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for primitive-not . */
  {
/* User-specified code, user code block part: beginning. */

    JITTERLISP_NOT_(JITTER_TOP_MAINSTACK(), JITTER_TOP_MAINSTACK());
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for primitive-not . */

  //fprintf (stderr, "..Executed instruction %s\n", "primitive-not");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the primitive-not argument macros so they can't be used
       by mistake in the instruction body coming next. */

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_EXIT")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_BRANCH")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_COMPUTED_GOTO")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(primitive-not, primitive_mnot, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for primitive-not, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction primitive-not-eqp */
  JITTER_INSTRUCTION_PROLOG_(primitive-not-eqp, primitive_mnot_meqp, hot)
  { /* This block begins with definitions for primitive-not-eqp . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       156
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         primitive-not-eqp
#   define JITTER_INSTRUCTION_NAME_AS_STRING "primitive-not-eqp"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "primitive-not-eqp"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME primitive_mnot_meqp

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is not branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is not branching: undefine branch
       macros so that they cannot be used by mistake. */
/* Locally poison JITTER_COMPUTED_GOTO . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_COMPUTED_GOTO")
# undef JITTER_COMPUTED_GOTO
# define JITTER_COMPUTED_GOTO JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_COMPUTED_GOTO, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_COMPUTED_GOTO
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_COMPUTED_GOTO . */

/* Locally poison JITTER_BRANCH . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_BRANCH")
# undef JITTER_BRANCH
# define JITTER_BRANCH JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_BRANCH, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_BRANCH
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_BRANCH . */

/* Locally poison JITTER_EXIT . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_EXIT")
# undef JITTER_EXIT
# define JITTER_EXIT JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_EXIT, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_EXIT
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_EXIT . */

  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0


#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of primitive-not-eqp ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "primitive-not-eqp"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for primitive-not-eqp . */
  {
/* User-specified code, user code block part: beginning. */

    JITTERLISP_NOT_EQP_(JITTER_TOP_MAINSTACK(),
                        JITTER_UNDER_TOP_MAINSTACK(), JITTER_TOP_MAINSTACK());
    JITTER_NIP_MAINSTACK();
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for primitive-not-eqp . */

  //fprintf (stderr, "..Executed instruction %s\n", "primitive-not-eqp");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the primitive-not-eqp argument macros so they can't be used
       by mistake in the instruction body coming next. */

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_EXIT")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_BRANCH")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_COMPUTED_GOTO")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(primitive-not-eqp, primitive_mnot_meqp, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for primitive-not-eqp, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction primitive-not-greaterp/fR */
  JITTER_INSTRUCTION_PROLOG_(primitive-not-greaterp/fR, primitive_mnot_mgreaterp__fR, hot)
  { /* This block begins with definitions for primitive-not-greaterp/fR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       157
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         primitive-not-greaterp/fR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "primitive-not-greaterp"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "primitive-not-greaterp/fR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME primitive_mnot_mgreaterp__fR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity varies depending on whether we have fast labels. */
#ifdef JITTER_HAVE_PATCH_IN
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
#else
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
#endif // #ifdef JITTER_HAVE_PATCH_IN

  /* Define argument-access macros for primitive-not-greaterp/fR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a "residual" fast label.  Define its
       _ARGF macro as the residual *index* (counting only fast labels, 0-based),
       so that at replication time we know what instruction address to patch in. */
#   define JITTER_ARGF0 0
    /* JITTER_ARG0 is intentionally not defined for a fast label. */

#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of primitive-not-greaterp/fR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "primitive-not-greaterp/fR"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for primitive-not-greaterp/fR . */
  {
/* User-specified code, user code block part: beginning. */

    JITTERLISPVM_CHECK_TYPES_2(FIXNUM, FIXNUM, JITTER_ARGF0);
    JITTERLISP_NOTGREATERP_(JITTER_TOP_MAINSTACK(),
                            JITTER_UNDER_TOP_MAINSTACK(),
                            JITTER_TOP_MAINSTACK());
    JITTER_NIP_MAINSTACK();
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for primitive-not-greaterp/fR . */

  //fprintf (stderr, "..Executed instruction %s\n", "primitive-not-greaterp/fR");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the primitive-not-greaterp/fR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(primitive-not-greaterp/fR, primitive_mnot_mgreaterp__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for primitive-not-greaterp/fR, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction primitive-not-lessp/fR */
  JITTER_INSTRUCTION_PROLOG_(primitive-not-lessp/fR, primitive_mnot_mlessp__fR, hot)
  { /* This block begins with definitions for primitive-not-lessp/fR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       158
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         primitive-not-lessp/fR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "primitive-not-lessp"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "primitive-not-lessp/fR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME primitive_mnot_mlessp__fR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity varies depending on whether we have fast labels. */
#ifdef JITTER_HAVE_PATCH_IN
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
#else
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
#endif // #ifdef JITTER_HAVE_PATCH_IN

  /* Define argument-access macros for primitive-not-lessp/fR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a "residual" fast label.  Define its
       _ARGF macro as the residual *index* (counting only fast labels, 0-based),
       so that at replication time we know what instruction address to patch in. */
#   define JITTER_ARGF0 0
    /* JITTER_ARG0 is intentionally not defined for a fast label. */

#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of primitive-not-lessp/fR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "primitive-not-lessp/fR"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for primitive-not-lessp/fR . */
  {
/* User-specified code, user code block part: beginning. */

    JITTERLISPVM_CHECK_TYPES_2(FIXNUM, FIXNUM, JITTER_ARGF0);
    JITTERLISP_NOTLESSP_(JITTER_TOP_MAINSTACK(),
                         JITTER_UNDER_TOP_MAINSTACK(), JITTER_TOP_MAINSTACK());
    JITTER_NIP_MAINSTACK();
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for primitive-not-lessp/fR . */

  //fprintf (stderr, "..Executed instruction %s\n", "primitive-not-lessp/fR");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the primitive-not-lessp/fR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(primitive-not-lessp/fR, primitive_mnot_mlessp__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for primitive-not-lessp/fR, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction primitive-nothingp */
  JITTER_INSTRUCTION_PROLOG_(primitive-nothingp, primitive_mnothingp, hot)
  { /* This block begins with definitions for primitive-nothingp . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       159
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         primitive-nothingp
#   define JITTER_INSTRUCTION_NAME_AS_STRING "primitive-nothingp"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "primitive-nothingp"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME primitive_mnothingp

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is not branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is not branching: undefine branch
       macros so that they cannot be used by mistake. */
/* Locally poison JITTER_COMPUTED_GOTO . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_COMPUTED_GOTO")
# undef JITTER_COMPUTED_GOTO
# define JITTER_COMPUTED_GOTO JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_COMPUTED_GOTO, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_COMPUTED_GOTO
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_COMPUTED_GOTO . */

/* Locally poison JITTER_BRANCH . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_BRANCH")
# undef JITTER_BRANCH
# define JITTER_BRANCH JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_BRANCH, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_BRANCH
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_BRANCH . */

/* Locally poison JITTER_EXIT . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_EXIT")
# undef JITTER_EXIT
# define JITTER_EXIT JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_EXIT, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_EXIT
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_EXIT . */

  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0


#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of primitive-nothingp ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "primitive-nothingp"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for primitive-nothingp . */
  {
/* User-specified code, user code block part: beginning. */

    JITTERLISP_NOTHINGP_(JITTER_TOP_MAINSTACK(), JITTER_TOP_MAINSTACK());
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for primitive-nothingp . */

  //fprintf (stderr, "..Executed instruction %s\n", "primitive-nothingp");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the primitive-nothingp argument macros so they can't be used
       by mistake in the instruction body coming next. */

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_EXIT")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_BRANCH")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_COMPUTED_GOTO")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(primitive-nothingp, primitive_mnothingp, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for primitive-nothingp, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction primitive-nullp */
  JITTER_INSTRUCTION_PROLOG_(primitive-nullp, primitive_mnullp, hot)
  { /* This block begins with definitions for primitive-nullp . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       160
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         primitive-nullp
#   define JITTER_INSTRUCTION_NAME_AS_STRING "primitive-nullp"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "primitive-nullp"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME primitive_mnullp

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is not branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is not branching: undefine branch
       macros so that they cannot be used by mistake. */
/* Locally poison JITTER_COMPUTED_GOTO . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_COMPUTED_GOTO")
# undef JITTER_COMPUTED_GOTO
# define JITTER_COMPUTED_GOTO JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_COMPUTED_GOTO, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_COMPUTED_GOTO
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_COMPUTED_GOTO . */

/* Locally poison JITTER_BRANCH . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_BRANCH")
# undef JITTER_BRANCH
# define JITTER_BRANCH JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_BRANCH, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_BRANCH
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_BRANCH . */

/* Locally poison JITTER_EXIT . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_EXIT")
# undef JITTER_EXIT
# define JITTER_EXIT JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_EXIT, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_EXIT
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_EXIT . */

  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0


#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of primitive-nullp ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "primitive-nullp"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for primitive-nullp . */
  {
/* User-specified code, user code block part: beginning. */

    JITTERLISP_NULLP_(JITTER_TOP_MAINSTACK(), JITTER_TOP_MAINSTACK());
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for primitive-nullp . */

  //fprintf (stderr, "..Executed instruction %s\n", "primitive-nullp");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the primitive-nullp argument macros so they can't be used
       by mistake in the instruction body coming next. */

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_EXIT")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_BRANCH")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_COMPUTED_GOTO")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(primitive-nullp, primitive_mnullp, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for primitive-nullp, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction primitive-one-minus/fR */
  JITTER_INSTRUCTION_PROLOG_(primitive-one-minus/fR, primitive_mone_mminus__fR, hot)
  { /* This block begins with definitions for primitive-one-minus/fR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       161
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         primitive-one-minus/fR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "primitive-one-minus"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "primitive-one-minus/fR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME primitive_mone_mminus__fR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity varies depending on whether we have fast labels. */
#ifdef JITTER_HAVE_PATCH_IN
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
#else
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
#endif // #ifdef JITTER_HAVE_PATCH_IN

  /* Define argument-access macros for primitive-one-minus/fR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a "residual" fast label.  Define its
       _ARGF macro as the residual *index* (counting only fast labels, 0-based),
       so that at replication time we know what instruction address to patch in. */
#   define JITTER_ARGF0 0
    /* JITTER_ARG0 is intentionally not defined for a fast label. */

#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of primitive-one-minus/fR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "primitive-one-minus/fR"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for primitive-one-minus/fR . */
  {
/* User-specified code, user code block part: beginning. */

    JITTERLISPVM_CHECK_TYPES_1(FIXNUM, JITTER_ARGF0);
    JITTERLISP_1MINUS_OR_OVERFLOW_(JITTER_TOP_MAINSTACK(),
                                   JITTER_TOP_MAINSTACK(),
                                   JITTER_ARGF0);
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for primitive-one-minus/fR . */

  //fprintf (stderr, "..Executed instruction %s\n", "primitive-one-minus/fR");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the primitive-one-minus/fR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(primitive-one-minus/fR, primitive_mone_mminus__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for primitive-one-minus/fR, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction primitive-one-plus/fR */
  JITTER_INSTRUCTION_PROLOG_(primitive-one-plus/fR, primitive_mone_mplus__fR, hot)
  { /* This block begins with definitions for primitive-one-plus/fR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       162
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         primitive-one-plus/fR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "primitive-one-plus"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "primitive-one-plus/fR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME primitive_mone_mplus__fR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity varies depending on whether we have fast labels. */
#ifdef JITTER_HAVE_PATCH_IN
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
#else
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
#endif // #ifdef JITTER_HAVE_PATCH_IN

  /* Define argument-access macros for primitive-one-plus/fR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a "residual" fast label.  Define its
       _ARGF macro as the residual *index* (counting only fast labels, 0-based),
       so that at replication time we know what instruction address to patch in. */
#   define JITTER_ARGF0 0
    /* JITTER_ARG0 is intentionally not defined for a fast label. */

#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of primitive-one-plus/fR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "primitive-one-plus/fR"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for primitive-one-plus/fR . */
  {
/* User-specified code, user code block part: beginning. */

    JITTERLISPVM_CHECK_TYPES_1(FIXNUM, JITTER_ARGF0);
    JITTERLISP_1PLUS_OR_OVERFLOW_(JITTER_TOP_MAINSTACK(),
                                  JITTER_TOP_MAINSTACK(),
                                  JITTER_ARGF0);
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for primitive-one-plus/fR . */

  //fprintf (stderr, "..Executed instruction %s\n", "primitive-one-plus/fR");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the primitive-one-plus/fR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(primitive-one-plus/fR, primitive_mone_mplus__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for primitive-one-plus/fR, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction primitive-positivep/fR */
  JITTER_INSTRUCTION_PROLOG_(primitive-positivep/fR, primitive_mpositivep__fR, hot)
  { /* This block begins with definitions for primitive-positivep/fR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       163
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         primitive-positivep/fR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "primitive-positivep"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "primitive-positivep/fR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME primitive_mpositivep__fR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity varies depending on whether we have fast labels. */
#ifdef JITTER_HAVE_PATCH_IN
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
#else
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
#endif // #ifdef JITTER_HAVE_PATCH_IN

  /* Define argument-access macros for primitive-positivep/fR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a "residual" fast label.  Define its
       _ARGF macro as the residual *index* (counting only fast labels, 0-based),
       so that at replication time we know what instruction address to patch in. */
#   define JITTER_ARGF0 0
    /* JITTER_ARG0 is intentionally not defined for a fast label. */

#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of primitive-positivep/fR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "primitive-positivep/fR"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for primitive-positivep/fR . */
  {
/* User-specified code, user code block part: beginning. */

    JITTERLISPVM_CHECK_TYPES_1(FIXNUM, JITTER_ARGF0);
    JITTERLISP_POSITIVEP_(JITTER_TOP_MAINSTACK(), JITTER_TOP_MAINSTACK());
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for primitive-positivep/fR . */

  //fprintf (stderr, "..Executed instruction %s\n", "primitive-positivep/fR");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the primitive-positivep/fR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(primitive-positivep/fR, primitive_mpositivep__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for primitive-positivep/fR, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction primitive-primordial-divided/fR */
  JITTER_INSTRUCTION_PROLOG_(primitive-primordial-divided/fR, primitive_mprimordial_mdivided__fR, hot)
  { /* This block begins with definitions for primitive-primordial-divided/fR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       164
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         primitive-primordial-divided/fR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "primitive-primordial-divided"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "primitive-primordial-divided/fR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME primitive_mprimordial_mdivided__fR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity varies depending on whether we have fast labels. */
#ifdef JITTER_HAVE_PATCH_IN
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
#else
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
#endif // #ifdef JITTER_HAVE_PATCH_IN

  /* Define argument-access macros for primitive-primordial-divided/fR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a "residual" fast label.  Define its
       _ARGF macro as the residual *index* (counting only fast labels, 0-based),
       so that at replication time we know what instruction address to patch in. */
#   define JITTER_ARGF0 0
    /* JITTER_ARG0 is intentionally not defined for a fast label. */

#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of primitive-primordial-divided/fR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "primitive-primordial-divided/fR"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for primitive-primordial-divided/fR . */
  {
/* User-specified code, user code block part: beginning. */

    JITTERLISPVM_CHECK_TYPES_2(FIXNUM, FIXNUM, JITTER_ARGF0);
    JITTERLISP_DIVIDED_OR_OVERFLOW_(JITTER_TOP_MAINSTACK(),
                                    JITTER_UNDER_TOP_MAINSTACK(),
                                    JITTER_TOP_MAINSTACK(),
                                    JITTER_ARGF0);
    JITTER_NIP_MAINSTACK();
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for primitive-primordial-divided/fR . */

  //fprintf (stderr, "..Executed instruction %s\n", "primitive-primordial-divided/fR");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the primitive-primordial-divided/fR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(primitive-primordial-divided/fR, primitive_mprimordial_mdivided__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for primitive-primordial-divided/fR, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction primitive-primordial-divided-unsafe/fR */
  JITTER_INSTRUCTION_PROLOG_(primitive-primordial-divided-unsafe/fR, primitive_mprimordial_mdivided_munsafe__fR, hot)
  { /* This block begins with definitions for primitive-primordial-divided-unsafe/fR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       165
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         primitive-primordial-divided-unsafe/fR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "primitive-primordial-divided-unsafe"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "primitive-primordial-divided-unsafe/fR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME primitive_mprimordial_mdivided_munsafe__fR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity varies depending on whether we have fast labels. */
#ifdef JITTER_HAVE_PATCH_IN
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
#else
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
#endif // #ifdef JITTER_HAVE_PATCH_IN

  /* Define argument-access macros for primitive-primordial-divided-unsafe/fR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a "residual" fast label.  Define its
       _ARGF macro as the residual *index* (counting only fast labels, 0-based),
       so that at replication time we know what instruction address to patch in. */
#   define JITTER_ARGF0 0
    /* JITTER_ARG0 is intentionally not defined for a fast label. */

#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of primitive-primordial-divided-unsafe/fR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "primitive-primordial-divided-unsafe/fR"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for primitive-primordial-divided-unsafe/fR . */
  {
/* User-specified code, user code block part: beginning. */

    /* The second argument has already been validated if we are using this. */
    JITTERLISPVM_CHECK_TYPES_2(FIXNUM, ANYTHING, JITTER_ARGF0);
    JITTERLISP_DIVIDED_UNSAFE_(JITTER_TOP_MAINSTACK(),
                               JITTER_UNDER_TOP_MAINSTACK(),
                               JITTER_TOP_MAINSTACK());
    JITTER_NIP_MAINSTACK();
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for primitive-primordial-divided-unsafe/fR . */

  //fprintf (stderr, "..Executed instruction %s\n", "primitive-primordial-divided-unsafe/fR");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the primitive-primordial-divided-unsafe/fR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(primitive-primordial-divided-unsafe/fR, primitive_mprimordial_mdivided_munsafe__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for primitive-primordial-divided-unsafe/fR, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction primitive-primordial-minus/fR */
  JITTER_INSTRUCTION_PROLOG_(primitive-primordial-minus/fR, primitive_mprimordial_mminus__fR, hot)
  { /* This block begins with definitions for primitive-primordial-minus/fR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       166
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         primitive-primordial-minus/fR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "primitive-primordial-minus"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "primitive-primordial-minus/fR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME primitive_mprimordial_mminus__fR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity varies depending on whether we have fast labels. */
#ifdef JITTER_HAVE_PATCH_IN
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
#else
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
#endif // #ifdef JITTER_HAVE_PATCH_IN

  /* Define argument-access macros for primitive-primordial-minus/fR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a "residual" fast label.  Define its
       _ARGF macro as the residual *index* (counting only fast labels, 0-based),
       so that at replication time we know what instruction address to patch in. */
#   define JITTER_ARGF0 0
    /* JITTER_ARG0 is intentionally not defined for a fast label. */

#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of primitive-primordial-minus/fR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "primitive-primordial-minus/fR"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for primitive-primordial-minus/fR . */
  {
/* User-specified code, user code block part: beginning. */

    JITTERLISPVM_CHECK_TYPES_2(FIXNUM, FIXNUM, JITTER_ARGF0);
    JITTERLISP_MINUS_OR_OVERFLOW_(JITTER_TOP_MAINSTACK(),
                                  JITTER_UNDER_TOP_MAINSTACK(),
                                  JITTER_TOP_MAINSTACK(),
                                  JITTER_ARGF0);
    JITTER_NIP_MAINSTACK();
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for primitive-primordial-minus/fR . */

  //fprintf (stderr, "..Executed instruction %s\n", "primitive-primordial-minus/fR");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the primitive-primordial-minus/fR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(primitive-primordial-minus/fR, primitive_mprimordial_mminus__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for primitive-primordial-minus/fR, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction primitive-primordial-plus/fR */
  JITTER_INSTRUCTION_PROLOG_(primitive-primordial-plus/fR, primitive_mprimordial_mplus__fR, hot)
  { /* This block begins with definitions for primitive-primordial-plus/fR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       167
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         primitive-primordial-plus/fR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "primitive-primordial-plus"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "primitive-primordial-plus/fR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME primitive_mprimordial_mplus__fR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity varies depending on whether we have fast labels. */
#ifdef JITTER_HAVE_PATCH_IN
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
#else
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
#endif // #ifdef JITTER_HAVE_PATCH_IN

  /* Define argument-access macros for primitive-primordial-plus/fR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a "residual" fast label.  Define its
       _ARGF macro as the residual *index* (counting only fast labels, 0-based),
       so that at replication time we know what instruction address to patch in. */
#   define JITTER_ARGF0 0
    /* JITTER_ARG0 is intentionally not defined for a fast label. */

#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of primitive-primordial-plus/fR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "primitive-primordial-plus/fR"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for primitive-primordial-plus/fR . */
  {
/* User-specified code, user code block part: beginning. */

    JITTERLISPVM_CHECK_TYPES_2(FIXNUM, FIXNUM, JITTER_ARGF0);
    JITTERLISP_PLUS_OR_OVERFLOW_(JITTER_TOP_MAINSTACK(),
                                 JITTER_UNDER_TOP_MAINSTACK(),
                                 JITTER_TOP_MAINSTACK(),
                                 JITTER_ARGF0);
    JITTER_NIP_MAINSTACK();
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for primitive-primordial-plus/fR . */

  //fprintf (stderr, "..Executed instruction %s\n", "primitive-primordial-plus/fR");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the primitive-primordial-plus/fR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(primitive-primordial-plus/fR, primitive_mprimordial_mplus__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for primitive-primordial-plus/fR, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction primitive-primordial-times/fR */
  JITTER_INSTRUCTION_PROLOG_(primitive-primordial-times/fR, primitive_mprimordial_mtimes__fR, hot)
  { /* This block begins with definitions for primitive-primordial-times/fR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       168
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         primitive-primordial-times/fR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "primitive-primordial-times"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "primitive-primordial-times/fR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME primitive_mprimordial_mtimes__fR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity varies depending on whether we have fast labels. */
#ifdef JITTER_HAVE_PATCH_IN
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
#else
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
#endif // #ifdef JITTER_HAVE_PATCH_IN

  /* Define argument-access macros for primitive-primordial-times/fR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a "residual" fast label.  Define its
       _ARGF macro as the residual *index* (counting only fast labels, 0-based),
       so that at replication time we know what instruction address to patch in. */
#   define JITTER_ARGF0 0
    /* JITTER_ARG0 is intentionally not defined for a fast label. */

#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of primitive-primordial-times/fR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "primitive-primordial-times/fR"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for primitive-primordial-times/fR . */
  {
/* User-specified code, user code block part: beginning. */

    JITTERLISPVM_CHECK_TYPES_2(FIXNUM, FIXNUM, JITTER_ARGF0);
    JITTERLISP_TIMES_OR_OVERFLOW_(JITTER_TOP_MAINSTACK(),
                                  JITTER_UNDER_TOP_MAINSTACK(),
                                  JITTER_TOP_MAINSTACK(),
                                  JITTER_ARGF0);
    JITTER_NIP_MAINSTACK();
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for primitive-primordial-times/fR . */

  //fprintf (stderr, "..Executed instruction %s\n", "primitive-primordial-times/fR");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the primitive-primordial-times/fR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(primitive-primordial-times/fR, primitive_mprimordial_mtimes__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for primitive-primordial-times/fR, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction primitive-quotient/fR */
  JITTER_INSTRUCTION_PROLOG_(primitive-quotient/fR, primitive_mquotient__fR, hot)
  { /* This block begins with definitions for primitive-quotient/fR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       169
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         primitive-quotient/fR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "primitive-quotient"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "primitive-quotient/fR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME primitive_mquotient__fR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity varies depending on whether we have fast labels. */
#ifdef JITTER_HAVE_PATCH_IN
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
#else
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
#endif // #ifdef JITTER_HAVE_PATCH_IN

  /* Define argument-access macros for primitive-quotient/fR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a "residual" fast label.  Define its
       _ARGF macro as the residual *index* (counting only fast labels, 0-based),
       so that at replication time we know what instruction address to patch in. */
#   define JITTER_ARGF0 0
    /* JITTER_ARG0 is intentionally not defined for a fast label. */

#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of primitive-quotient/fR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "primitive-quotient/fR"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for primitive-quotient/fR . */
  {
/* User-specified code, user code block part: beginning. */

    JITTERLISPVM_CHECK_TYPES_2(FIXNUM, FIXNUM, JITTER_ARGF0);
    JITTERLISP_QUOTIENT_OR_OVERFLOW_(JITTER_TOP_MAINSTACK(),
                                     JITTER_UNDER_TOP_MAINSTACK(),
                                     JITTER_TOP_MAINSTACK(),
                                     JITTER_ARGF0);
    JITTER_NIP_MAINSTACK();
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for primitive-quotient/fR . */

  //fprintf (stderr, "..Executed instruction %s\n", "primitive-quotient/fR");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the primitive-quotient/fR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(primitive-quotient/fR, primitive_mquotient__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for primitive-quotient/fR, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction primitive-quotient-unsafe/fR */
  JITTER_INSTRUCTION_PROLOG_(primitive-quotient-unsafe/fR, primitive_mquotient_munsafe__fR, hot)
  { /* This block begins with definitions for primitive-quotient-unsafe/fR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       170
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         primitive-quotient-unsafe/fR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "primitive-quotient-unsafe"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "primitive-quotient-unsafe/fR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME primitive_mquotient_munsafe__fR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity varies depending on whether we have fast labels. */
#ifdef JITTER_HAVE_PATCH_IN
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
#else
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
#endif // #ifdef JITTER_HAVE_PATCH_IN

  /* Define argument-access macros for primitive-quotient-unsafe/fR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a "residual" fast label.  Define its
       _ARGF macro as the residual *index* (counting only fast labels, 0-based),
       so that at replication time we know what instruction address to patch in. */
#   define JITTER_ARGF0 0
    /* JITTER_ARG0 is intentionally not defined for a fast label. */

#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of primitive-quotient-unsafe/fR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "primitive-quotient-unsafe/fR"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for primitive-quotient-unsafe/fR . */
  {
/* User-specified code, user code block part: beginning. */

    /* The second argument has already been validated if we are using this. */
    JITTERLISPVM_CHECK_TYPES_2(FIXNUM, ANYTHING, JITTER_ARGF0);
    JITTERLISP_QUOTIENT_UNSAFE_(JITTER_TOP_MAINSTACK(),
                               JITTER_UNDER_TOP_MAINSTACK(),
                               JITTER_TOP_MAINSTACK());
    JITTER_NIP_MAINSTACK();
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for primitive-quotient-unsafe/fR . */

  //fprintf (stderr, "..Executed instruction %s\n", "primitive-quotient-unsafe/fR");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the primitive-quotient-unsafe/fR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(primitive-quotient-unsafe/fR, primitive_mquotient_munsafe__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for primitive-quotient-unsafe/fR, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction primitive-remainder/fR */
  JITTER_INSTRUCTION_PROLOG_(primitive-remainder/fR, primitive_mremainder__fR, hot)
  { /* This block begins with definitions for primitive-remainder/fR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       171
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         primitive-remainder/fR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "primitive-remainder"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "primitive-remainder/fR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME primitive_mremainder__fR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity varies depending on whether we have fast labels. */
#ifdef JITTER_HAVE_PATCH_IN
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
#else
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
#endif // #ifdef JITTER_HAVE_PATCH_IN

  /* Define argument-access macros for primitive-remainder/fR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a "residual" fast label.  Define its
       _ARGF macro as the residual *index* (counting only fast labels, 0-based),
       so that at replication time we know what instruction address to patch in. */
#   define JITTER_ARGF0 0
    /* JITTER_ARG0 is intentionally not defined for a fast label. */

#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of primitive-remainder/fR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "primitive-remainder/fR"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for primitive-remainder/fR . */
  {
/* User-specified code, user code block part: beginning. */

    JITTERLISPVM_CHECK_TYPES_2(FIXNUM, FIXNUM, JITTER_ARGF0);
    JITTERLISP_REMAINDER_OR_OVERFLOW_(JITTER_TOP_MAINSTACK(),
                                      JITTER_UNDER_TOP_MAINSTACK(),
                                      JITTER_TOP_MAINSTACK(),
                                      JITTER_ARGF0);
    JITTER_NIP_MAINSTACK();
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for primitive-remainder/fR . */

  //fprintf (stderr, "..Executed instruction %s\n", "primitive-remainder/fR");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the primitive-remainder/fR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(primitive-remainder/fR, primitive_mremainder__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for primitive-remainder/fR, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction primitive-remainder-unsafe/fR */
  JITTER_INSTRUCTION_PROLOG_(primitive-remainder-unsafe/fR, primitive_mremainder_munsafe__fR, hot)
  { /* This block begins with definitions for primitive-remainder-unsafe/fR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       172
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         primitive-remainder-unsafe/fR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "primitive-remainder-unsafe"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "primitive-remainder-unsafe/fR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME primitive_mremainder_munsafe__fR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity varies depending on whether we have fast labels. */
#ifdef JITTER_HAVE_PATCH_IN
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
#else
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
#endif // #ifdef JITTER_HAVE_PATCH_IN

  /* Define argument-access macros for primitive-remainder-unsafe/fR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a "residual" fast label.  Define its
       _ARGF macro as the residual *index* (counting only fast labels, 0-based),
       so that at replication time we know what instruction address to patch in. */
#   define JITTER_ARGF0 0
    /* JITTER_ARG0 is intentionally not defined for a fast label. */

#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of primitive-remainder-unsafe/fR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "primitive-remainder-unsafe/fR"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for primitive-remainder-unsafe/fR . */
  {
/* User-specified code, user code block part: beginning. */

    /* The second argument has already been validated if we are using this. */
    JITTERLISPVM_CHECK_TYPES_2(FIXNUM, ANYTHING, JITTER_ARGF0);
    JITTERLISP_REMAINDER_UNSAFE_(JITTER_TOP_MAINSTACK(),
                                 JITTER_UNDER_TOP_MAINSTACK(),
                                 JITTER_TOP_MAINSTACK());
    JITTER_NIP_MAINSTACK();
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for primitive-remainder-unsafe/fR . */

  //fprintf (stderr, "..Executed instruction %s\n", "primitive-remainder-unsafe/fR");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the primitive-remainder-unsafe/fR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(primitive-remainder-unsafe/fR, primitive_mremainder_munsafe__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for primitive-remainder-unsafe/fR, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction primitive-set-carb-special/fR */
  JITTER_INSTRUCTION_PROLOG_(primitive-set-carb-special/fR, primitive_mset_mcarb_mspecial__fR, hot)
  { /* This block begins with definitions for primitive-set-carb-special/fR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       173
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         primitive-set-carb-special/fR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "primitive-set-carb-special"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "primitive-set-carb-special/fR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME primitive_mset_mcarb_mspecial__fR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity varies depending on whether we have fast labels. */
#ifdef JITTER_HAVE_PATCH_IN
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
#else
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
#endif // #ifdef JITTER_HAVE_PATCH_IN

  /* Define argument-access macros for primitive-set-carb-special/fR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a "residual" fast label.  Define its
       _ARGF macro as the residual *index* (counting only fast labels, 0-based),
       so that at replication time we know what instruction address to patch in. */
#   define JITTER_ARGF0 0
    /* JITTER_ARG0 is intentionally not defined for a fast label. */

#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of primitive-set-carb-special/fR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "primitive-set-carb-special/fR"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for primitive-set-carb-special/fR . */
  {
/* User-specified code, user code block part: beginning. */

    JITTERLISPVM_CHECK_TYPES_2(CONS, ANYTHING, JITTER_ARGF0);
    jitterlisp_object useless __attribute__ ((unused));
    JITTERLISP_SET_CARB_(useless,
                         JITTER_UNDER_TOP_MAINSTACK(), JITTER_TOP_MAINSTACK());
    /* Leave the two operands on the stack. */
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for primitive-set-carb-special/fR . */

  //fprintf (stderr, "..Executed instruction %s\n", "primitive-set-carb-special/fR");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the primitive-set-carb-special/fR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(primitive-set-carb-special/fR, primitive_mset_mcarb_mspecial__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for primitive-set-carb-special/fR, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction primitive-set-cdrb-special/fR */
  JITTER_INSTRUCTION_PROLOG_(primitive-set-cdrb-special/fR, primitive_mset_mcdrb_mspecial__fR, hot)
  { /* This block begins with definitions for primitive-set-cdrb-special/fR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       174
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         primitive-set-cdrb-special/fR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "primitive-set-cdrb-special"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "primitive-set-cdrb-special/fR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME primitive_mset_mcdrb_mspecial__fR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity varies depending on whether we have fast labels. */
#ifdef JITTER_HAVE_PATCH_IN
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
#else
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
#endif // #ifdef JITTER_HAVE_PATCH_IN

  /* Define argument-access macros for primitive-set-cdrb-special/fR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a "residual" fast label.  Define its
       _ARGF macro as the residual *index* (counting only fast labels, 0-based),
       so that at replication time we know what instruction address to patch in. */
#   define JITTER_ARGF0 0
    /* JITTER_ARG0 is intentionally not defined for a fast label. */

#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of primitive-set-cdrb-special/fR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "primitive-set-cdrb-special/fR"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for primitive-set-cdrb-special/fR . */
  {
/* User-specified code, user code block part: beginning. */

    JITTERLISPVM_CHECK_TYPES_2(CONS, ANYTHING, JITTER_ARGF0);
    jitterlisp_object useless __attribute__ ((unused));
    JITTERLISP_SET_CDRB_(useless,
                         JITTER_UNDER_TOP_MAINSTACK(), JITTER_TOP_MAINSTACK());
    /* Leave the two operands on the stack. */
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for primitive-set-cdrb-special/fR . */

  //fprintf (stderr, "..Executed instruction %s\n", "primitive-set-cdrb-special/fR");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the primitive-set-cdrb-special/fR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(primitive-set-cdrb-special/fR, primitive_mset_mcdrb_mspecial__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for primitive-set-cdrb-special/fR, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction primitive-symbolp */
  JITTER_INSTRUCTION_PROLOG_(primitive-symbolp, primitive_msymbolp, hot)
  { /* This block begins with definitions for primitive-symbolp . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       175
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         primitive-symbolp
#   define JITTER_INSTRUCTION_NAME_AS_STRING "primitive-symbolp"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "primitive-symbolp"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME primitive_msymbolp

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is not branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is not branching: undefine branch
       macros so that they cannot be used by mistake. */
/* Locally poison JITTER_COMPUTED_GOTO . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_COMPUTED_GOTO")
# undef JITTER_COMPUTED_GOTO
# define JITTER_COMPUTED_GOTO JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_COMPUTED_GOTO, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_COMPUTED_GOTO
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_COMPUTED_GOTO . */

/* Locally poison JITTER_BRANCH . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_BRANCH")
# undef JITTER_BRANCH
# define JITTER_BRANCH JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_BRANCH, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_BRANCH
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_BRANCH . */

/* Locally poison JITTER_EXIT . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_EXIT")
# undef JITTER_EXIT
# define JITTER_EXIT JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_EXIT, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_EXIT
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_EXIT . */

  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0


#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of primitive-symbolp ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "primitive-symbolp"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for primitive-symbolp . */
  {
/* User-specified code, user code block part: beginning. */

    JITTERLISP_SYMBOLP_(JITTER_TOP_MAINSTACK(), JITTER_TOP_MAINSTACK());
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for primitive-symbolp . */

  //fprintf (stderr, "..Executed instruction %s\n", "primitive-symbolp");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the primitive-symbolp argument macros so they can't be used
       by mistake in the instruction body coming next. */

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_EXIT")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_BRANCH")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_COMPUTED_GOTO")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(primitive-symbolp, primitive_msymbolp, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for primitive-symbolp, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction primitive-two-divided/fR */
  JITTER_INSTRUCTION_PROLOG_(primitive-two-divided/fR, primitive_mtwo_mdivided__fR, hot)
  { /* This block begins with definitions for primitive-two-divided/fR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       176
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         primitive-two-divided/fR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "primitive-two-divided"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "primitive-two-divided/fR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME primitive_mtwo_mdivided__fR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity varies depending on whether we have fast labels. */
#ifdef JITTER_HAVE_PATCH_IN
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
#else
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
#endif // #ifdef JITTER_HAVE_PATCH_IN

  /* Define argument-access macros for primitive-two-divided/fR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a "residual" fast label.  Define its
       _ARGF macro as the residual *index* (counting only fast labels, 0-based),
       so that at replication time we know what instruction address to patch in. */
#   define JITTER_ARGF0 0
    /* JITTER_ARG0 is intentionally not defined for a fast label. */

#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of primitive-two-divided/fR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "primitive-two-divided/fR"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for primitive-two-divided/fR . */
  {
/* User-specified code, user code block part: beginning. */

    JITTERLISPVM_CHECK_TYPES_1(FIXNUM, JITTER_ARGF0);
    JITTERLISP_2DIVIDED_(JITTER_TOP_MAINSTACK(), JITTER_TOP_MAINSTACK());
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for primitive-two-divided/fR . */

  //fprintf (stderr, "..Executed instruction %s\n", "primitive-two-divided/fR");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the primitive-two-divided/fR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(primitive-two-divided/fR, primitive_mtwo_mdivided__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for primitive-two-divided/fR, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction primitive-two-quotient/fR */
  JITTER_INSTRUCTION_PROLOG_(primitive-two-quotient/fR, primitive_mtwo_mquotient__fR, hot)
  { /* This block begins with definitions for primitive-two-quotient/fR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       177
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         primitive-two-quotient/fR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "primitive-two-quotient"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "primitive-two-quotient/fR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME primitive_mtwo_mquotient__fR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity varies depending on whether we have fast labels. */
#ifdef JITTER_HAVE_PATCH_IN
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
#else
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
#endif // #ifdef JITTER_HAVE_PATCH_IN

  /* Define argument-access macros for primitive-two-quotient/fR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a "residual" fast label.  Define its
       _ARGF macro as the residual *index* (counting only fast labels, 0-based),
       so that at replication time we know what instruction address to patch in. */
#   define JITTER_ARGF0 0
    /* JITTER_ARG0 is intentionally not defined for a fast label. */

#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of primitive-two-quotient/fR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "primitive-two-quotient/fR"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for primitive-two-quotient/fR . */
  {
/* User-specified code, user code block part: beginning. */

    JITTERLISPVM_CHECK_TYPES_1(FIXNUM, JITTER_ARGF0);
    JITTERLISP_2QUOTIENT_(JITTER_TOP_MAINSTACK(), JITTER_TOP_MAINSTACK());
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for primitive-two-quotient/fR . */

  //fprintf (stderr, "..Executed instruction %s\n", "primitive-two-quotient/fR");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the primitive-two-quotient/fR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(primitive-two-quotient/fR, primitive_mtwo_mquotient__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for primitive-two-quotient/fR, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction primitive-two-remainder/fR */
  JITTER_INSTRUCTION_PROLOG_(primitive-two-remainder/fR, primitive_mtwo_mremainder__fR, hot)
  { /* This block begins with definitions for primitive-two-remainder/fR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       178
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         primitive-two-remainder/fR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "primitive-two-remainder"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "primitive-two-remainder/fR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME primitive_mtwo_mremainder__fR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity varies depending on whether we have fast labels. */
#ifdef JITTER_HAVE_PATCH_IN
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
#else
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
#endif // #ifdef JITTER_HAVE_PATCH_IN

  /* Define argument-access macros for primitive-two-remainder/fR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a "residual" fast label.  Define its
       _ARGF macro as the residual *index* (counting only fast labels, 0-based),
       so that at replication time we know what instruction address to patch in. */
#   define JITTER_ARGF0 0
    /* JITTER_ARG0 is intentionally not defined for a fast label. */

#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of primitive-two-remainder/fR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "primitive-two-remainder/fR"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for primitive-two-remainder/fR . */
  {
/* User-specified code, user code block part: beginning. */

    JITTERLISPVM_CHECK_TYPES_1(FIXNUM, JITTER_ARGF0);
    JITTERLISP_2REMAINDER_(JITTER_TOP_MAINSTACK(), JITTER_TOP_MAINSTACK());
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for primitive-two-remainder/fR . */

  //fprintf (stderr, "..Executed instruction %s\n", "primitive-two-remainder/fR");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the primitive-two-remainder/fR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(primitive-two-remainder/fR, primitive_mtwo_mremainder__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for primitive-two-remainder/fR, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction primitive-two-times/fR */
  JITTER_INSTRUCTION_PROLOG_(primitive-two-times/fR, primitive_mtwo_mtimes__fR, hot)
  { /* This block begins with definitions for primitive-two-times/fR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       179
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         primitive-two-times/fR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "primitive-two-times"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "primitive-two-times/fR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME primitive_mtwo_mtimes__fR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity varies depending on whether we have fast labels. */
#ifdef JITTER_HAVE_PATCH_IN
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
#else
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
#endif // #ifdef JITTER_HAVE_PATCH_IN

  /* Define argument-access macros for primitive-two-times/fR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a "residual" fast label.  Define its
       _ARGF macro as the residual *index* (counting only fast labels, 0-based),
       so that at replication time we know what instruction address to patch in. */
#   define JITTER_ARGF0 0
    /* JITTER_ARG0 is intentionally not defined for a fast label. */

#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of primitive-two-times/fR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "primitive-two-times/fR"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for primitive-two-times/fR . */
  {
/* User-specified code, user code block part: beginning. */

    JITTERLISPVM_CHECK_TYPES_1(FIXNUM, JITTER_ARGF0);
    JITTERLISP_2TIMES_OR_OVERFLOW_(JITTER_TOP_MAINSTACK(),
                                   JITTER_TOP_MAINSTACK(),
                                   JITTER_ARGF0);
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for primitive-two-times/fR . */

  //fprintf (stderr, "..Executed instruction %s\n", "primitive-two-times/fR");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the primitive-two-times/fR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(primitive-two-times/fR, primitive_mtwo_mtimes__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for primitive-two-times/fR, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction primitive-uniquep */
  JITTER_INSTRUCTION_PROLOG_(primitive-uniquep, primitive_muniquep, hot)
  { /* This block begins with definitions for primitive-uniquep . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       180
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         primitive-uniquep
#   define JITTER_INSTRUCTION_NAME_AS_STRING "primitive-uniquep"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "primitive-uniquep"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME primitive_muniquep

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is not branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is not branching: undefine branch
       macros so that they cannot be used by mistake. */
/* Locally poison JITTER_COMPUTED_GOTO . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_COMPUTED_GOTO")
# undef JITTER_COMPUTED_GOTO
# define JITTER_COMPUTED_GOTO JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_COMPUTED_GOTO, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_COMPUTED_GOTO
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_COMPUTED_GOTO . */

/* Locally poison JITTER_BRANCH . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_BRANCH")
# undef JITTER_BRANCH
# define JITTER_BRANCH JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_BRANCH, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_BRANCH
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_BRANCH . */

/* Locally poison JITTER_EXIT . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_EXIT")
# undef JITTER_EXIT
# define JITTER_EXIT JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_EXIT, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_EXIT
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_EXIT . */

  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0


#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of primitive-uniquep ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "primitive-uniquep"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for primitive-uniquep . */
  {
/* User-specified code, user code block part: beginning. */

    JITTERLISP_UNIQUEP_(JITTER_TOP_MAINSTACK(), JITTER_TOP_MAINSTACK());
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for primitive-uniquep . */

  //fprintf (stderr, "..Executed instruction %s\n", "primitive-uniquep");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the primitive-uniquep argument macros so they can't be used
       by mistake in the instruction body coming next. */

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_EXIT")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_BRANCH")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_COMPUTED_GOTO")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(primitive-uniquep, primitive_muniquep, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for primitive-uniquep, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction primitive-zerop/fR */
  JITTER_INSTRUCTION_PROLOG_(primitive-zerop/fR, primitive_mzerop__fR, hot)
  { /* This block begins with definitions for primitive-zerop/fR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       181
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         primitive-zerop/fR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "primitive-zerop"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "primitive-zerop/fR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME primitive_mzerop__fR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity varies depending on whether we have fast labels. */
#ifdef JITTER_HAVE_PATCH_IN
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
#else
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
#endif // #ifdef JITTER_HAVE_PATCH_IN

  /* Define argument-access macros for primitive-zerop/fR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a "residual" fast label.  Define its
       _ARGF macro as the residual *index* (counting only fast labels, 0-based),
       so that at replication time we know what instruction address to patch in. */
#   define JITTER_ARGF0 0
    /* JITTER_ARG0 is intentionally not defined for a fast label. */

#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of primitive-zerop/fR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "primitive-zerop/fR"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for primitive-zerop/fR . */
  {
/* User-specified code, user code block part: beginning. */

    JITTERLISPVM_CHECK_TYPES_1(FIXNUM, JITTER_ARGF0);
    JITTERLISP_ZEROP_(JITTER_TOP_MAINSTACK(), JITTER_TOP_MAINSTACK());
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for primitive-zerop/fR . */

  //fprintf (stderr, "..Executed instruction %s\n", "primitive-zerop/fR");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the primitive-zerop/fR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(primitive-zerop/fR, primitive_mzerop__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for primitive-zerop/fR, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction procedure-prolog */
  JITTER_INSTRUCTION_PROLOG_(procedure-prolog, procedure_mprolog, hot)
  { /* This block begins with definitions for procedure-prolog . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       182
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         procedure-prolog
#   define JITTER_INSTRUCTION_NAME_AS_STRING "procedure-prolog"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "procedure-prolog"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME procedure_mprolog

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0


  /* This specialized instruction is a non-replacement callee.
     Set the link pointer if needed... */
  union jitter_word _jitter_the_link;
  _JITTER_PROCEDURE_PROLOG (_jitter_the_link);
  const void *_jitter_the_link_label = _jitter_the_link.label;
  /* ...And make it accessible to this instruction thru a macro. */
# undef JITTER_LINK
# define JITTER_LINK _jitter_the_link_label

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of procedure-prolog ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "procedure-prolog"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for procedure-prolog . */
  {
/* User-specified code, user code block part: beginning. */

    /* Fill the return stack slot with the return address.  The return
       stack has already been pushed (with an unspecified value on the
       top) by the caller. */
    JITTER_TOP_RETURNSTACK() = (jitterlisp_object) JITTER_LINK;
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for procedure-prolog . */

  //fprintf (stderr, "..Executed instruction %s\n", "procedure-prolog");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the procedure-prolog argument macros so they can't be used
       by mistake in the instruction body coming next. */

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

  /* Undefine the link macro. */
#   undef JITTER_LINK

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(procedure-prolog, procedure_mprolog, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for procedure-prolog, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction push-false */
  JITTER_INSTRUCTION_PROLOG_(push-false, push_mfalse, hot)
  { /* This block begins with definitions for push-false . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       183
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         push-false
#   define JITTER_INSTRUCTION_NAME_AS_STRING "push-false"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "push-false"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME push_mfalse

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is not branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is not branching: undefine branch
       macros so that they cannot be used by mistake. */
/* Locally poison JITTER_COMPUTED_GOTO . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_COMPUTED_GOTO")
# undef JITTER_COMPUTED_GOTO
# define JITTER_COMPUTED_GOTO JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_COMPUTED_GOTO, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_COMPUTED_GOTO
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_COMPUTED_GOTO . */

/* Locally poison JITTER_BRANCH . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_BRANCH")
# undef JITTER_BRANCH
# define JITTER_BRANCH JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_BRANCH, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_BRANCH
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_BRANCH . */

/* Locally poison JITTER_EXIT . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_EXIT")
# undef JITTER_EXIT
# define JITTER_EXIT JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_EXIT, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_EXIT
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_EXIT . */

  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0


#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of push-false ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "push-false"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for push-false . */
  {
/* User-specified code, user code block part: beginning. */

    JITTER_PUSH_MAINSTACK(JITTERLISP_FALSE);
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for push-false . */

  //fprintf (stderr, "..Executed instruction %s\n", "push-false");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the push-false argument macros so they can't be used
       by mistake in the instruction body coming next. */

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_EXIT")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_BRANCH")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_COMPUTED_GOTO")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(push-false, push_mfalse, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for push-false, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction push-global/nR/fR */
  JITTER_INSTRUCTION_PROLOG_(push-global/nR/fR, push_mglobal__nR__fR, cold)
  { /* This block begins with definitions for push-global/nR/fR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       184
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         push-global/nR/fR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "push-global"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "push-global/nR/fR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME push_mglobal__nR__fR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity varies depending on whether we have fast labels. */
#ifdef JITTER_HAVE_PATCH_IN
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
#else
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 2
#endif // #ifdef JITTER_HAVE_PATCH_IN

  /* Define argument-access macros for push-global/nR/fR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a residual literal. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)

    /* The 1th argument is a "residual" fast label.  Define its
       _ARGF macro as the residual *index* (counting only fast labels, 0-based),
       so that at replication time we know what instruction address to patch in. */
#   define JITTER_ARGF1 0
    /* JITTER_ARG1 is intentionally not defined for a fast label. */

#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
    /* The 0th argument is a residual literal. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of push-global/nR/fR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "push-global/nR/fR"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for push-global/nR/fR . */
  {
/* User-specified code, user code block part: beginning. */

    jitterlisp_object tagged_symbol = JITTER_ARGN0;
    struct jitterlisp_symbol * symbol = JITTERLISP_SYMBOL_DECODE(tagged_symbol);

#ifndef JITTERLISP_UNSAFE
    JITTER_BRANCH_FAST_IF_EQUAL (symbol->global_value, JITTERLISP_UNDEFINED,
                                 JITTER_ARGF1);
#endif // #ifndef JITTERLISP_UNSAFE

//    JITTER_PUSH_MAINSTACK(symbol->global_value);
    JITTER_PUSH_UNSPECIFIED_MAINSTACK();
    JITTER_TOP_MAINSTACK() = symbol->global_value;
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for push-global/nR/fR . */

  //fprintf (stderr, "..Executed instruction %s\n", "push-global/nR/fR");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the push-global/nR/fR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(push-global/nR/fR, push_mglobal__nR__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for push-global/nR/fR, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction push-literal/nR */
  JITTER_INSTRUCTION_PROLOG_(push-literal/nR, push_mliteral__nR, cold)
  { /* This block begins with definitions for push-literal/nR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       185
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         push-literal/nR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "push-literal"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "push-literal/nR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME push_mliteral__nR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is not branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is not branching: undefine branch
       macros so that they cannot be used by mistake. */
/* Locally poison JITTER_COMPUTED_GOTO . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_COMPUTED_GOTO")
# undef JITTER_COMPUTED_GOTO
# define JITTER_COMPUTED_GOTO JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_COMPUTED_GOTO, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_COMPUTED_GOTO
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_COMPUTED_GOTO . */

/* Locally poison JITTER_BRANCH . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_BRANCH")
# undef JITTER_BRANCH
# define JITTER_BRANCH JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_BRANCH, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_BRANCH
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_BRANCH . */

/* Locally poison JITTER_EXIT . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_EXIT")
# undef JITTER_EXIT
# define JITTER_EXIT JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_EXIT, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_EXIT
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_EXIT . */

  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1

    /* The 0th argument is a residual literal. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0


#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of push-literal/nR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "push-literal/nR"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for push-literal/nR . */
  {
/* User-specified code, user code block part: beginning. */

    jitterlisp_object k = JITTER_ARGN0;
    JITTER_PUSH_MAINSTACK(k);
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for push-literal/nR . */

  //fprintf (stderr, "..Executed instruction %s\n", "push-literal/nR");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the push-literal/nR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_EXIT")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_BRANCH")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_COMPUTED_GOTO")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(push-literal/nR, push_mliteral__nR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for push-literal/nR, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction push-nil */
  JITTER_INSTRUCTION_PROLOG_(push-nil, push_mnil, hot)
  { /* This block begins with definitions for push-nil . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       186
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         push-nil
#   define JITTER_INSTRUCTION_NAME_AS_STRING "push-nil"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "push-nil"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME push_mnil

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is not branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is not branching: undefine branch
       macros so that they cannot be used by mistake. */
/* Locally poison JITTER_COMPUTED_GOTO . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_COMPUTED_GOTO")
# undef JITTER_COMPUTED_GOTO
# define JITTER_COMPUTED_GOTO JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_COMPUTED_GOTO, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_COMPUTED_GOTO
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_COMPUTED_GOTO . */

/* Locally poison JITTER_BRANCH . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_BRANCH")
# undef JITTER_BRANCH
# define JITTER_BRANCH JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_BRANCH, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_BRANCH
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_BRANCH . */

/* Locally poison JITTER_EXIT . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_EXIT")
# undef JITTER_EXIT
# define JITTER_EXIT JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_EXIT, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_EXIT
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_EXIT . */

  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0


#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of push-nil ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "push-nil"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for push-nil . */
  {
/* User-specified code, user code block part: beginning. */

    JITTER_PUSH_MAINSTACK(JITTERLISP_EMPTY_LIST);
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for push-nil . */

  //fprintf (stderr, "..Executed instruction %s\n", "push-nil");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the push-nil argument macros so they can't be used
       by mistake in the instruction body coming next. */

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_EXIT")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_BRANCH")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_COMPUTED_GOTO")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(push-nil, push_mnil, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for push-nil, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction push-nothing */
  JITTER_INSTRUCTION_PROLOG_(push-nothing, push_mnothing, hot)
  { /* This block begins with definitions for push-nothing . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       187
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         push-nothing
#   define JITTER_INSTRUCTION_NAME_AS_STRING "push-nothing"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "push-nothing"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME push_mnothing

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is not branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is not branching: undefine branch
       macros so that they cannot be used by mistake. */
/* Locally poison JITTER_COMPUTED_GOTO . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_COMPUTED_GOTO")
# undef JITTER_COMPUTED_GOTO
# define JITTER_COMPUTED_GOTO JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_COMPUTED_GOTO, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_COMPUTED_GOTO
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_COMPUTED_GOTO . */

/* Locally poison JITTER_BRANCH . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_BRANCH")
# undef JITTER_BRANCH
# define JITTER_BRANCH JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_BRANCH, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_BRANCH
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_BRANCH . */

/* Locally poison JITTER_EXIT . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_EXIT")
# undef JITTER_EXIT
# define JITTER_EXIT JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_EXIT, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_EXIT
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_EXIT . */

  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0


#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of push-nothing ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "push-nothing"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for push-nothing . */
  {
/* User-specified code, user code block part: beginning. */

    JITTER_PUSH_MAINSTACK(JITTERLISP_NOTHING);
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for push-nothing . */

  //fprintf (stderr, "..Executed instruction %s\n", "push-nothing");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the push-nothing argument macros so they can't be used
       by mistake in the instruction body coming next. */

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_EXIT")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_BRANCH")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_COMPUTED_GOTO")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(push-nothing, push_mnothing, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for push-nothing, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction push-one */
  JITTER_INSTRUCTION_PROLOG_(push-one, push_mone, hot)
  { /* This block begins with definitions for push-one . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       188
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         push-one
#   define JITTER_INSTRUCTION_NAME_AS_STRING "push-one"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "push-one"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME push_mone

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is not branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is not branching: undefine branch
       macros so that they cannot be used by mistake. */
/* Locally poison JITTER_COMPUTED_GOTO . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_COMPUTED_GOTO")
# undef JITTER_COMPUTED_GOTO
# define JITTER_COMPUTED_GOTO JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_COMPUTED_GOTO, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_COMPUTED_GOTO
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_COMPUTED_GOTO . */

/* Locally poison JITTER_BRANCH . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_BRANCH")
# undef JITTER_BRANCH
# define JITTER_BRANCH JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_BRANCH, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_BRANCH
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_BRANCH . */

/* Locally poison JITTER_EXIT . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_EXIT")
# undef JITTER_EXIT
# define JITTER_EXIT JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_EXIT, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_EXIT
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_EXIT . */

  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0


#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of push-one ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "push-one"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for push-one . */
  {
/* User-specified code, user code block part: beginning. */

    JITTER_PUSH_MAINSTACK(JITTERLISP_FIXNUM_ENCODE(1));
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for push-one . */

  //fprintf (stderr, "..Executed instruction %s\n", "push-one");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the push-one argument macros so they can't be used
       by mistake in the instruction body coming next. */

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_EXIT")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_BRANCH")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_COMPUTED_GOTO")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(push-one, push_mone, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for push-one, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction push-register/%rR */
  JITTER_INSTRUCTION_PROLOG_(push-register/%rR, push_mregister___rrR, cold)
  { /* This block begins with definitions for push-register/%rR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       189
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         push-register/%rR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "push-register"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "push-register/%rR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME push_mregister___rrR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is not branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is not branching: undefine branch
       macros so that they cannot be used by mistake. */
/* Locally poison JITTER_COMPUTED_GOTO . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_COMPUTED_GOTO")
# undef JITTER_COMPUTED_GOTO
# define JITTER_COMPUTED_GOTO JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_COMPUTED_GOTO, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_COMPUTED_GOTO
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_COMPUTED_GOTO . */

/* Locally poison JITTER_BRANCH . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_BRANCH")
# undef JITTER_BRANCH
# define JITTER_BRANCH JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_BRANCH, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_BRANCH
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_BRANCH . */

/* Locally poison JITTER_EXIT . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_EXIT")
# undef JITTER_EXIT
# define JITTER_EXIT JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_EXIT, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_EXIT
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_EXIT . */

  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1

    /* The 0th argument is a slow (therefore residual, passed as an offset)
        register. */
  /* Define a macro expanding to the slow register offset. */
#if defined(JITTER_DISPATCH_NO_THREADING)
# define JITTER_SLOW_REGISTER_OFFSET0 (JITTER_RESIDUAL_ARGUMENT_0.fixnum)
#elif defined (JITTER_DISPATCH_MINIMAL_THREADING)
# define JITTER_SLOW_REGISTER_OFFSET0 ((((union jitter_word*)jitter_ip)[0]).fixnum)
#else
# define JITTER_SLOW_REGISTER_OFFSET0 ((((union jitter_word*)jitter_ip)[1]).fixnum)
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
  /* Define a macro expanding to an l-value for the VM register content. */
#   define JITTER_ARG0  JITTER_SLOW_REGISTER_FROM_OFFSET(r, JITTER_SLOW_REGISTER_OFFSET0)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0


#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of push-register/%rR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "push-register/%rR"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for push-register/%rR . */
  {
/* User-specified code, user code block part: beginning. */

    jitterlisp_object k = JITTER_ARG0;
    JITTER_PUSH_MAINSTACK(k);
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for push-register/%rR . */

  //fprintf (stderr, "..Executed instruction %s\n", "push-register/%rR");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the push-register/%rR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_EXIT")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_BRANCH")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_COMPUTED_GOTO")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(push-register/%rR, push_mregister___rrR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for push-register/%rR, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction push-unspecified */
  JITTER_INSTRUCTION_PROLOG_(push-unspecified, push_munspecified, hot)
  { /* This block begins with definitions for push-unspecified . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       190
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         push-unspecified
#   define JITTER_INSTRUCTION_NAME_AS_STRING "push-unspecified"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "push-unspecified"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME push_munspecified

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is not branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is not branching: undefine branch
       macros so that they cannot be used by mistake. */
/* Locally poison JITTER_COMPUTED_GOTO . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_COMPUTED_GOTO")
# undef JITTER_COMPUTED_GOTO
# define JITTER_COMPUTED_GOTO JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_COMPUTED_GOTO, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_COMPUTED_GOTO
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_COMPUTED_GOTO . */

/* Locally poison JITTER_BRANCH . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_BRANCH")
# undef JITTER_BRANCH
# define JITTER_BRANCH JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_BRANCH, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_BRANCH
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_BRANCH . */

/* Locally poison JITTER_EXIT . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_EXIT")
# undef JITTER_EXIT
# define JITTER_EXIT JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_EXIT, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_EXIT
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_EXIT . */

  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0


#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of push-unspecified ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "push-unspecified"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for push-unspecified . */
  {
/* User-specified code, user code block part: beginning. */

    JITTER_PUSH_UNSPECIFIED_MAINSTACK();
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for push-unspecified . */

  //fprintf (stderr, "..Executed instruction %s\n", "push-unspecified");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the push-unspecified argument macros so they can't be used
       by mistake in the instruction body coming next. */

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_EXIT")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_BRANCH")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_COMPUTED_GOTO")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(push-unspecified, push_munspecified, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for push-unspecified, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction push-zero */
  JITTER_INSTRUCTION_PROLOG_(push-zero, push_mzero, hot)
  { /* This block begins with definitions for push-zero . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       191
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         push-zero
#   define JITTER_INSTRUCTION_NAME_AS_STRING "push-zero"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "push-zero"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME push_mzero

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is not branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is not branching: undefine branch
       macros so that they cannot be used by mistake. */
/* Locally poison JITTER_COMPUTED_GOTO . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_COMPUTED_GOTO")
# undef JITTER_COMPUTED_GOTO
# define JITTER_COMPUTED_GOTO JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_COMPUTED_GOTO, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_COMPUTED_GOTO
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_COMPUTED_GOTO . */

/* Locally poison JITTER_BRANCH . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_BRANCH")
# undef JITTER_BRANCH
# define JITTER_BRANCH JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_BRANCH, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_BRANCH
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_BRANCH . */

/* Locally poison JITTER_EXIT . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_EXIT")
# undef JITTER_EXIT
# define JITTER_EXIT JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_EXIT, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_EXIT
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_EXIT . */

  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0


#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of push-zero ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "push-zero"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for push-zero . */
  {
/* User-specified code, user code block part: beginning. */

    JITTER_PUSH_MAINSTACK(JITTERLISP_FIXNUM_ENCODE(0));
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for push-zero . */

  //fprintf (stderr, "..Executed instruction %s\n", "push-zero");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the push-zero argument macros so they can't be used
       by mistake in the instruction body coming next. */

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_EXIT")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_BRANCH")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_COMPUTED_GOTO")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(push-zero, push_mzero, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for push-zero, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction register-to-register/%rR/%rR */
  JITTER_INSTRUCTION_PROLOG_(register-to-register/%rR/%rR, register_mto_mregister___rrR___rrR, cold)
  { /* This block begins with definitions for register-to-register/%rR/%rR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       192
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         register-to-register/%rR/%rR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "register-to-register"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "register-to-register/%rR/%rR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME register_mto_mregister___rrR___rrR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is not branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is not branching: undefine branch
       macros so that they cannot be used by mistake. */
/* Locally poison JITTER_COMPUTED_GOTO . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_COMPUTED_GOTO")
# undef JITTER_COMPUTED_GOTO
# define JITTER_COMPUTED_GOTO JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_COMPUTED_GOTO, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_COMPUTED_GOTO
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_COMPUTED_GOTO . */

/* Locally poison JITTER_BRANCH . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_BRANCH")
# undef JITTER_BRANCH
# define JITTER_BRANCH JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_BRANCH, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_BRANCH
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_BRANCH . */

/* Locally poison JITTER_EXIT . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_EXIT")
# undef JITTER_EXIT
# define JITTER_EXIT JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_EXIT, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_EXIT
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_EXIT . */

  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 2

    /* The 0th argument is a slow (therefore residual, passed as an offset)
        register. */
  /* Define a macro expanding to the slow register offset. */
#if defined(JITTER_DISPATCH_NO_THREADING)
# define JITTER_SLOW_REGISTER_OFFSET0 (JITTER_RESIDUAL_ARGUMENT_0.fixnum)
#elif defined (JITTER_DISPATCH_MINIMAL_THREADING)
# define JITTER_SLOW_REGISTER_OFFSET0 ((((union jitter_word*)jitter_ip)[0]).fixnum)
#else
# define JITTER_SLOW_REGISTER_OFFSET0 ((((union jitter_word*)jitter_ip)[1]).fixnum)
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
  /* Define a macro expanding to an l-value for the VM register content. */
#   define JITTER_ARG0  JITTER_SLOW_REGISTER_FROM_OFFSET(r, JITTER_SLOW_REGISTER_OFFSET0)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a slow (therefore residual, passed as an offset)
        register. */
  /* Define a macro expanding to the slow register offset. */
#if defined(JITTER_DISPATCH_NO_THREADING)
# define JITTER_SLOW_REGISTER_OFFSET1 (JITTER_RESIDUAL_ARGUMENT_1.fixnum)
#elif defined (JITTER_DISPATCH_MINIMAL_THREADING)
# define JITTER_SLOW_REGISTER_OFFSET1 ((((union jitter_word*)jitter_ip)[1]).fixnum)
#else
# define JITTER_SLOW_REGISTER_OFFSET1 ((((union jitter_word*)jitter_ip)[2]).fixnum)
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
  /* Define a macro expanding to an l-value for the VM register content. */
#   define JITTER_ARG1  JITTER_SLOW_REGISTER_FROM_OFFSET(r, JITTER_SLOW_REGISTER_OFFSET1)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1


#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of register-to-register/%rR/%rR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "register-to-register/%rR/%rR"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for register-to-register/%rR/%rR . */
  {
/* User-specified code, user code block part: beginning. */

    JITTER_ARG1 = JITTER_ARG0;
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for register-to-register/%rR/%rR . */

  //fprintf (stderr, "..Executed instruction %s\n", "register-to-register/%rR/%rR");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the register-to-register/%rR/%rR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_EXIT")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_BRANCH")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_COMPUTED_GOTO")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(register-to-register/%rR/%rR, register_mto_mregister___rrR___rrR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for register-to-register/%rR/%rR, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction restore-register/%rR */
  JITTER_INSTRUCTION_PROLOG_(restore-register/%rR, restore_mregister___rrR, cold)
  { /* This block begins with definitions for restore-register/%rR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       193
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         restore-register/%rR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "restore-register"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "restore-register/%rR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME restore_mregister___rrR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is not branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is not branching: undefine branch
       macros so that they cannot be used by mistake. */
/* Locally poison JITTER_COMPUTED_GOTO . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_COMPUTED_GOTO")
# undef JITTER_COMPUTED_GOTO
# define JITTER_COMPUTED_GOTO JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_COMPUTED_GOTO, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_COMPUTED_GOTO
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_COMPUTED_GOTO . */

/* Locally poison JITTER_BRANCH . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_BRANCH")
# undef JITTER_BRANCH
# define JITTER_BRANCH JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_BRANCH, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_BRANCH
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_BRANCH . */

/* Locally poison JITTER_EXIT . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_EXIT")
# undef JITTER_EXIT
# define JITTER_EXIT JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_EXIT, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_EXIT
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_EXIT . */

  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1

    /* The 0th argument is a slow (therefore residual, passed as an offset)
        register. */
  /* Define a macro expanding to the slow register offset. */
#if defined(JITTER_DISPATCH_NO_THREADING)
# define JITTER_SLOW_REGISTER_OFFSET0 (JITTER_RESIDUAL_ARGUMENT_0.fixnum)
#elif defined (JITTER_DISPATCH_MINIMAL_THREADING)
# define JITTER_SLOW_REGISTER_OFFSET0 ((((union jitter_word*)jitter_ip)[0]).fixnum)
#else
# define JITTER_SLOW_REGISTER_OFFSET0 ((((union jitter_word*)jitter_ip)[1]).fixnum)
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
  /* Define a macro expanding to an l-value for the VM register content. */
#   define JITTER_ARG0  JITTER_SLOW_REGISTER_FROM_OFFSET(r, JITTER_SLOW_REGISTER_OFFSET0)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0


#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of restore-register/%rR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "restore-register/%rR"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for restore-register/%rR . */
  {
/* User-specified code, user code block part: beginning. */

    JITTER_ARG0 = JITTER_TOP_RETURNSTACK();
    JITTER_DROP_RETURNSTACK();
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for restore-register/%rR . */

  //fprintf (stderr, "..Executed instruction %s\n", "restore-register/%rR");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the restore-register/%rR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_EXIT")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_BRANCH")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_COMPUTED_GOTO")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(restore-register/%rR, restore_mregister___rrR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for restore-register/%rR, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction return */
  JITTER_INSTRUCTION_PROLOG_(return, return, hot)
  { /* This block begins with definitions for return . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       194
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         return
#   define JITTER_INSTRUCTION_NAME_AS_STRING "return"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "return"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME return

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is returning, and relocatable. */
#   define JITTER_RETURN  _JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0


#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of return ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "return"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for return . */
  {
/* User-specified code, user code block part: beginning. */

    jitter_uint return_address = JITTER_TOP_RETURNSTACK();
    JITTER_DROP_RETURNSTACK();
    JITTER_RETURN(return_address);
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for return . */

  //fprintf (stderr, "..Executed instruction %s\n", "return");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the return argument macros so they can't be used
       by mistake in the instruction body coming next. */

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(return, return, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for return, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction save-register/%rR */
  JITTER_INSTRUCTION_PROLOG_(save-register/%rR, save_mregister___rrR, cold)
  { /* This block begins with definitions for save-register/%rR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       195
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         save-register/%rR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "save-register"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "save-register/%rR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME save_mregister___rrR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is not branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is not branching: undefine branch
       macros so that they cannot be used by mistake. */
/* Locally poison JITTER_COMPUTED_GOTO . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_COMPUTED_GOTO")
# undef JITTER_COMPUTED_GOTO
# define JITTER_COMPUTED_GOTO JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_COMPUTED_GOTO, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_COMPUTED_GOTO
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_COMPUTED_GOTO . */

/* Locally poison JITTER_BRANCH . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_BRANCH")
# undef JITTER_BRANCH
# define JITTER_BRANCH JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_BRANCH, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_BRANCH
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_BRANCH . */

/* Locally poison JITTER_EXIT . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("JITTER_EXIT")
# undef JITTER_EXIT
# define JITTER_EXIT JITTER_POISONED_WITHOUT_ATTRIBUTE (JITTER_EXIT, "branching")
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef JITTER_EXIT
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of JITTER_EXIT . */

  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1

    /* The 0th argument is a slow (therefore residual, passed as an offset)
        register. */
  /* Define a macro expanding to the slow register offset. */
#if defined(JITTER_DISPATCH_NO_THREADING)
# define JITTER_SLOW_REGISTER_OFFSET0 (JITTER_RESIDUAL_ARGUMENT_0.fixnum)
#elif defined (JITTER_DISPATCH_MINIMAL_THREADING)
# define JITTER_SLOW_REGISTER_OFFSET0 ((((union jitter_word*)jitter_ip)[0]).fixnum)
#else
# define JITTER_SLOW_REGISTER_OFFSET0 ((((union jitter_word*)jitter_ip)[1]).fixnum)
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
  /* Define a macro expanding to an l-value for the VM register content. */
#   define JITTER_ARG0  JITTER_SLOW_REGISTER_FROM_OFFSET(r, JITTER_SLOW_REGISTER_OFFSET0)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0


#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of save-register/%rR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "save-register/%rR"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for save-register/%rR . */
  {
/* User-specified code, user code block part: beginning. */

    JITTER_PUSH_RETURNSTACK(JITTER_ARG0);
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for save-register/%rR . */

  //fprintf (stderr, "..Executed instruction %s\n", "save-register/%rR");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the save-register/%rR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_EXIT")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_BRANCH")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("JITTER_COMPUTED_GOTO")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(save-register/%rR, save_mregister___rrR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for save-register/%rR, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction tail-call/n0/retR */
  JITTER_INSTRUCTION_PROLOG_(tail-call/n0/retR, tail_mcall__n0__retR, cold)
  { /* This block begins with definitions for tail-call/n0/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       196
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         tail-call/n0/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "tail-call"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "tail-call/n0/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME tail_mcall__n0__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is a non-replacement and a caller.
       Its 1-th argument, a literal, is the return address where to jump
       back after the procedure returns.  Branch-and-link
       functionality is enabled for this instruction. */
/* This instruction is relocatable: use more efficient branches
   which can generate defects. */
#   undef JITTER_BRANCH_AND_LINK
#   define JITTER_BRANCH_AND_LINK      _JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   define JITTER_BRANCH_AND_LINK_WITH _JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK
#   define JITTER_BRANCH_FAST_AND_LINK _JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is returning, and relocatable. */
#   define JITTER_RETURN  _JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1

    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 0L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1


#if defined(JITTER_DISPATCH_NO_THREADING)             \
    && (! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)  \
        || /* is this a replacement? */ 0)
  /* We use the implicit argument at the end of the calling.
     instruction to discover the procedure return address. */
  const void * const _jitter_return_pointer
    __attribute__ ((unused)) = JITTER_ARGP1;
  /* And make it accessible to the user (who will usually call 
     JITTER_BRANCH_AND_LINK) thru a nice macro. */
# define _JITTER_RETURN_ADDRESS _jitter_return_pointer
#endif

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of tail-call/n0/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "tail-call/n0/retR"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for tail-call/n0/retR . */
  {
/* User-specified code, user code block part: beginning. */

    const jitter_uint in_arity = JITTER_ARGN0;
    jitterlisp_object callee = JITTER_AT_DEPTH_MAINSTACK(in_arity);
    struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(callee);

    if (c->kind == jitterlisp_closure_type_compiled)
      {
        /* Extract the current return address from the return stack, to be
           reused.  Differently from non-tail calls, don't push anything on
           the return stack: the callee will overwrite the top with its
           current value, which is what we want. */
        jitterlispvm_program_point current_link
          = (jitterlispvm_program_point) JITTER_TOP_RETURNSTACK();

        /* Branch-and-relink to the native code, whose first instruction
           will be a prolog. */
        struct jitterlisp_compiled_closure *cc = & c->compiled;
        JITTER_BRANCH_AND_LINK_WITH(cc->first_program_point, current_link);
      }
    else
      {
        /* Unfortunately I cannot really tail-call from compiled code to
           interpreted code.  Instead I will call the interpreter as a C
           function and then return. */
        const struct jitterlisp_interpreted_closure *ic = & c->interpreted;

        /* Push an element on the main stack.  This way we can ensure that
           every actual is accessible thru memory in a contiguous array,
           even if the main stack is TOS-optimized.  Compute the address
           (on the main stack backing) where the actuals begin.

           Notice that the interpreted function we are calling is allowed
           to call into compiled code in its turn.  This is not a problem,
           as we are not moving stack pointers down until the call ends:
           the unused part of the main and return stacks is available to
           the callee. */
        JITTER_PUSH_UNSPECIFIED_MAINSTACK();
        jitterlisp_object *actuals
          // FIXME: add a stack operator to compute this address.
          = (& JITTER_UNDER_TOP_MAINSTACK()) - in_arity + 1;

        /* Call the interpreter. */
        jitterlisp_object interpretation_result
          = jitterlisp_call_interpreted (ic, actuals, in_arity);

        /* Remove as many elements as the in-arity plus one (the callee) from
           the stack, without affecting the top.  Unless JITTER_ARGN0 is
           residual this whole loops compiles to one instruction when the main
           stack is TOS-optimized, and doesn't touch memory. */
        int i;
        for (i = 0; i < in_arity + 1; i ++)
          JITTER_NIP_MAINSTACK();

        /* Now the stack is one element higher than it was before the call,
           containing the unspecified element at the top.  Replace it with
           the result.  Again this doesn't touch memory. */
        JITTER_TOP_MAINSTACK() = interpretation_result;

        /* Return to our original caller. */
        jitter_uint return_address = JITTER_TOP_RETURNSTACK();
        JITTER_DROP_RETURNSTACK();
        JITTER_RETURN(return_address);
      }
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for tail-call/n0/retR . */

  //fprintf (stderr, "..Executed instruction %s\n", "tail-call/n0/retR");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the tail-call/n0/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#if    defined(JITTER_DISPATCH_NO_THREADING)         \
    && ! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)
# undef _JITTER_RETURN_ADDRESS
#endif

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(tail-call/n0/retR, tail_mcall__n0__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for tail-call/n0/retR, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction tail-call/n1/retR */
  JITTER_INSTRUCTION_PROLOG_(tail-call/n1/retR, tail_mcall__n1__retR, cold)
  { /* This block begins with definitions for tail-call/n1/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       197
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         tail-call/n1/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "tail-call"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "tail-call/n1/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME tail_mcall__n1__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is a non-replacement and a caller.
       Its 1-th argument, a literal, is the return address where to jump
       back after the procedure returns.  Branch-and-link
       functionality is enabled for this instruction. */
/* This instruction is relocatable: use more efficient branches
   which can generate defects. */
#   undef JITTER_BRANCH_AND_LINK
#   define JITTER_BRANCH_AND_LINK      _JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   define JITTER_BRANCH_AND_LINK_WITH _JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK
#   define JITTER_BRANCH_FAST_AND_LINK _JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is returning, and relocatable. */
#   define JITTER_RETURN  _JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1

    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 1L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1


#if defined(JITTER_DISPATCH_NO_THREADING)             \
    && (! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)  \
        || /* is this a replacement? */ 0)
  /* We use the implicit argument at the end of the calling.
     instruction to discover the procedure return address. */
  const void * const _jitter_return_pointer
    __attribute__ ((unused)) = JITTER_ARGP1;
  /* And make it accessible to the user (who will usually call 
     JITTER_BRANCH_AND_LINK) thru a nice macro. */
# define _JITTER_RETURN_ADDRESS _jitter_return_pointer
#endif

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of tail-call/n1/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "tail-call/n1/retR"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for tail-call/n1/retR . */
  {
/* User-specified code, user code block part: beginning. */

    const jitter_uint in_arity = JITTER_ARGN0;
    jitterlisp_object callee = JITTER_AT_DEPTH_MAINSTACK(in_arity);
    struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(callee);

    if (c->kind == jitterlisp_closure_type_compiled)
      {
        /* Extract the current return address from the return stack, to be
           reused.  Differently from non-tail calls, don't push anything on
           the return stack: the callee will overwrite the top with its
           current value, which is what we want. */
        jitterlispvm_program_point current_link
          = (jitterlispvm_program_point) JITTER_TOP_RETURNSTACK();

        /* Branch-and-relink to the native code, whose first instruction
           will be a prolog. */
        struct jitterlisp_compiled_closure *cc = & c->compiled;
        JITTER_BRANCH_AND_LINK_WITH(cc->first_program_point, current_link);
      }
    else
      {
        /* Unfortunately I cannot really tail-call from compiled code to
           interpreted code.  Instead I will call the interpreter as a C
           function and then return. */
        const struct jitterlisp_interpreted_closure *ic = & c->interpreted;

        /* Push an element on the main stack.  This way we can ensure that
           every actual is accessible thru memory in a contiguous array,
           even if the main stack is TOS-optimized.  Compute the address
           (on the main stack backing) where the actuals begin.

           Notice that the interpreted function we are calling is allowed
           to call into compiled code in its turn.  This is not a problem,
           as we are not moving stack pointers down until the call ends:
           the unused part of the main and return stacks is available to
           the callee. */
        JITTER_PUSH_UNSPECIFIED_MAINSTACK();
        jitterlisp_object *actuals
          // FIXME: add a stack operator to compute this address.
          = (& JITTER_UNDER_TOP_MAINSTACK()) - in_arity + 1;

        /* Call the interpreter. */
        jitterlisp_object interpretation_result
          = jitterlisp_call_interpreted (ic, actuals, in_arity);

        /* Remove as many elements as the in-arity plus one (the callee) from
           the stack, without affecting the top.  Unless JITTER_ARGN0 is
           residual this whole loops compiles to one instruction when the main
           stack is TOS-optimized, and doesn't touch memory. */
        int i;
        for (i = 0; i < in_arity + 1; i ++)
          JITTER_NIP_MAINSTACK();

        /* Now the stack is one element higher than it was before the call,
           containing the unspecified element at the top.  Replace it with
           the result.  Again this doesn't touch memory. */
        JITTER_TOP_MAINSTACK() = interpretation_result;

        /* Return to our original caller. */
        jitter_uint return_address = JITTER_TOP_RETURNSTACK();
        JITTER_DROP_RETURNSTACK();
        JITTER_RETURN(return_address);
      }
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for tail-call/n1/retR . */

  //fprintf (stderr, "..Executed instruction %s\n", "tail-call/n1/retR");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the tail-call/n1/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#if    defined(JITTER_DISPATCH_NO_THREADING)         \
    && ! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)
# undef _JITTER_RETURN_ADDRESS
#endif

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(tail-call/n1/retR, tail_mcall__n1__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for tail-call/n1/retR, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction tail-call/n2/retR */
  JITTER_INSTRUCTION_PROLOG_(tail-call/n2/retR, tail_mcall__n2__retR, cold)
  { /* This block begins with definitions for tail-call/n2/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       198
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         tail-call/n2/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "tail-call"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "tail-call/n2/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME tail_mcall__n2__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is a non-replacement and a caller.
       Its 1-th argument, a literal, is the return address where to jump
       back after the procedure returns.  Branch-and-link
       functionality is enabled for this instruction. */
/* This instruction is relocatable: use more efficient branches
   which can generate defects. */
#   undef JITTER_BRANCH_AND_LINK
#   define JITTER_BRANCH_AND_LINK      _JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   define JITTER_BRANCH_AND_LINK_WITH _JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK
#   define JITTER_BRANCH_FAST_AND_LINK _JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is returning, and relocatable. */
#   define JITTER_RETURN  _JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1

    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 2L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1


#if defined(JITTER_DISPATCH_NO_THREADING)             \
    && (! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)  \
        || /* is this a replacement? */ 0)
  /* We use the implicit argument at the end of the calling.
     instruction to discover the procedure return address. */
  const void * const _jitter_return_pointer
    __attribute__ ((unused)) = JITTER_ARGP1;
  /* And make it accessible to the user (who will usually call 
     JITTER_BRANCH_AND_LINK) thru a nice macro. */
# define _JITTER_RETURN_ADDRESS _jitter_return_pointer
#endif

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of tail-call/n2/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "tail-call/n2/retR"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for tail-call/n2/retR . */
  {
/* User-specified code, user code block part: beginning. */

    const jitter_uint in_arity = JITTER_ARGN0;
    jitterlisp_object callee = JITTER_AT_DEPTH_MAINSTACK(in_arity);
    struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(callee);

    if (c->kind == jitterlisp_closure_type_compiled)
      {
        /* Extract the current return address from the return stack, to be
           reused.  Differently from non-tail calls, don't push anything on
           the return stack: the callee will overwrite the top with its
           current value, which is what we want. */
        jitterlispvm_program_point current_link
          = (jitterlispvm_program_point) JITTER_TOP_RETURNSTACK();

        /* Branch-and-relink to the native code, whose first instruction
           will be a prolog. */
        struct jitterlisp_compiled_closure *cc = & c->compiled;
        JITTER_BRANCH_AND_LINK_WITH(cc->first_program_point, current_link);
      }
    else
      {
        /* Unfortunately I cannot really tail-call from compiled code to
           interpreted code.  Instead I will call the interpreter as a C
           function and then return. */
        const struct jitterlisp_interpreted_closure *ic = & c->interpreted;

        /* Push an element on the main stack.  This way we can ensure that
           every actual is accessible thru memory in a contiguous array,
           even if the main stack is TOS-optimized.  Compute the address
           (on the main stack backing) where the actuals begin.

           Notice that the interpreted function we are calling is allowed
           to call into compiled code in its turn.  This is not a problem,
           as we are not moving stack pointers down until the call ends:
           the unused part of the main and return stacks is available to
           the callee. */
        JITTER_PUSH_UNSPECIFIED_MAINSTACK();
        jitterlisp_object *actuals
          // FIXME: add a stack operator to compute this address.
          = (& JITTER_UNDER_TOP_MAINSTACK()) - in_arity + 1;

        /* Call the interpreter. */
        jitterlisp_object interpretation_result
          = jitterlisp_call_interpreted (ic, actuals, in_arity);

        /* Remove as many elements as the in-arity plus one (the callee) from
           the stack, without affecting the top.  Unless JITTER_ARGN0 is
           residual this whole loops compiles to one instruction when the main
           stack is TOS-optimized, and doesn't touch memory. */
        int i;
        for (i = 0; i < in_arity + 1; i ++)
          JITTER_NIP_MAINSTACK();

        /* Now the stack is one element higher than it was before the call,
           containing the unspecified element at the top.  Replace it with
           the result.  Again this doesn't touch memory. */
        JITTER_TOP_MAINSTACK() = interpretation_result;

        /* Return to our original caller. */
        jitter_uint return_address = JITTER_TOP_RETURNSTACK();
        JITTER_DROP_RETURNSTACK();
        JITTER_RETURN(return_address);
      }
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for tail-call/n2/retR . */

  //fprintf (stderr, "..Executed instruction %s\n", "tail-call/n2/retR");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the tail-call/n2/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#if    defined(JITTER_DISPATCH_NO_THREADING)         \
    && ! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)
# undef _JITTER_RETURN_ADDRESS
#endif

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(tail-call/n2/retR, tail_mcall__n2__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for tail-call/n2/retR, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction tail-call/n3/retR */
  JITTER_INSTRUCTION_PROLOG_(tail-call/n3/retR, tail_mcall__n3__retR, cold)
  { /* This block begins with definitions for tail-call/n3/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       199
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         tail-call/n3/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "tail-call"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "tail-call/n3/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME tail_mcall__n3__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is a non-replacement and a caller.
       Its 1-th argument, a literal, is the return address where to jump
       back after the procedure returns.  Branch-and-link
       functionality is enabled for this instruction. */
/* This instruction is relocatable: use more efficient branches
   which can generate defects. */
#   undef JITTER_BRANCH_AND_LINK
#   define JITTER_BRANCH_AND_LINK      _JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   define JITTER_BRANCH_AND_LINK_WITH _JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK
#   define JITTER_BRANCH_FAST_AND_LINK _JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is returning, and relocatable. */
#   define JITTER_RETURN  _JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1

    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 3L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1


#if defined(JITTER_DISPATCH_NO_THREADING)             \
    && (! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)  \
        || /* is this a replacement? */ 0)
  /* We use the implicit argument at the end of the calling.
     instruction to discover the procedure return address. */
  const void * const _jitter_return_pointer
    __attribute__ ((unused)) = JITTER_ARGP1;
  /* And make it accessible to the user (who will usually call 
     JITTER_BRANCH_AND_LINK) thru a nice macro. */
# define _JITTER_RETURN_ADDRESS _jitter_return_pointer
#endif

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of tail-call/n3/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "tail-call/n3/retR"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for tail-call/n3/retR . */
  {
/* User-specified code, user code block part: beginning. */

    const jitter_uint in_arity = JITTER_ARGN0;
    jitterlisp_object callee = JITTER_AT_DEPTH_MAINSTACK(in_arity);
    struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(callee);

    if (c->kind == jitterlisp_closure_type_compiled)
      {
        /* Extract the current return address from the return stack, to be
           reused.  Differently from non-tail calls, don't push anything on
           the return stack: the callee will overwrite the top with its
           current value, which is what we want. */
        jitterlispvm_program_point current_link
          = (jitterlispvm_program_point) JITTER_TOP_RETURNSTACK();

        /* Branch-and-relink to the native code, whose first instruction
           will be a prolog. */
        struct jitterlisp_compiled_closure *cc = & c->compiled;
        JITTER_BRANCH_AND_LINK_WITH(cc->first_program_point, current_link);
      }
    else
      {
        /* Unfortunately I cannot really tail-call from compiled code to
           interpreted code.  Instead I will call the interpreter as a C
           function and then return. */
        const struct jitterlisp_interpreted_closure *ic = & c->interpreted;

        /* Push an element on the main stack.  This way we can ensure that
           every actual is accessible thru memory in a contiguous array,
           even if the main stack is TOS-optimized.  Compute the address
           (on the main stack backing) where the actuals begin.

           Notice that the interpreted function we are calling is allowed
           to call into compiled code in its turn.  This is not a problem,
           as we are not moving stack pointers down until the call ends:
           the unused part of the main and return stacks is available to
           the callee. */
        JITTER_PUSH_UNSPECIFIED_MAINSTACK();
        jitterlisp_object *actuals
          // FIXME: add a stack operator to compute this address.
          = (& JITTER_UNDER_TOP_MAINSTACK()) - in_arity + 1;

        /* Call the interpreter. */
        jitterlisp_object interpretation_result
          = jitterlisp_call_interpreted (ic, actuals, in_arity);

        /* Remove as many elements as the in-arity plus one (the callee) from
           the stack, without affecting the top.  Unless JITTER_ARGN0 is
           residual this whole loops compiles to one instruction when the main
           stack is TOS-optimized, and doesn't touch memory. */
        int i;
        for (i = 0; i < in_arity + 1; i ++)
          JITTER_NIP_MAINSTACK();

        /* Now the stack is one element higher than it was before the call,
           containing the unspecified element at the top.  Replace it with
           the result.  Again this doesn't touch memory. */
        JITTER_TOP_MAINSTACK() = interpretation_result;

        /* Return to our original caller. */
        jitter_uint return_address = JITTER_TOP_RETURNSTACK();
        JITTER_DROP_RETURNSTACK();
        JITTER_RETURN(return_address);
      }
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for tail-call/n3/retR . */

  //fprintf (stderr, "..Executed instruction %s\n", "tail-call/n3/retR");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the tail-call/n3/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#if    defined(JITTER_DISPATCH_NO_THREADING)         \
    && ! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)
# undef _JITTER_RETURN_ADDRESS
#endif

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(tail-call/n3/retR, tail_mcall__n3__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for tail-call/n3/retR, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction tail-call/n4/retR */
  JITTER_INSTRUCTION_PROLOG_(tail-call/n4/retR, tail_mcall__n4__retR, cold)
  { /* This block begins with definitions for tail-call/n4/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       200
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         tail-call/n4/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "tail-call"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "tail-call/n4/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME tail_mcall__n4__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is a non-replacement and a caller.
       Its 1-th argument, a literal, is the return address where to jump
       back after the procedure returns.  Branch-and-link
       functionality is enabled for this instruction. */
/* This instruction is relocatable: use more efficient branches
   which can generate defects. */
#   undef JITTER_BRANCH_AND_LINK
#   define JITTER_BRANCH_AND_LINK      _JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   define JITTER_BRANCH_AND_LINK_WITH _JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK
#   define JITTER_BRANCH_FAST_AND_LINK _JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is returning, and relocatable. */
#   define JITTER_RETURN  _JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1

    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 4L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1


#if defined(JITTER_DISPATCH_NO_THREADING)             \
    && (! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)  \
        || /* is this a replacement? */ 0)
  /* We use the implicit argument at the end of the calling.
     instruction to discover the procedure return address. */
  const void * const _jitter_return_pointer
    __attribute__ ((unused)) = JITTER_ARGP1;
  /* And make it accessible to the user (who will usually call 
     JITTER_BRANCH_AND_LINK) thru a nice macro. */
# define _JITTER_RETURN_ADDRESS _jitter_return_pointer
#endif

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of tail-call/n4/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "tail-call/n4/retR"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for tail-call/n4/retR . */
  {
/* User-specified code, user code block part: beginning. */

    const jitter_uint in_arity = JITTER_ARGN0;
    jitterlisp_object callee = JITTER_AT_DEPTH_MAINSTACK(in_arity);
    struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(callee);

    if (c->kind == jitterlisp_closure_type_compiled)
      {
        /* Extract the current return address from the return stack, to be
           reused.  Differently from non-tail calls, don't push anything on
           the return stack: the callee will overwrite the top with its
           current value, which is what we want. */
        jitterlispvm_program_point current_link
          = (jitterlispvm_program_point) JITTER_TOP_RETURNSTACK();

        /* Branch-and-relink to the native code, whose first instruction
           will be a prolog. */
        struct jitterlisp_compiled_closure *cc = & c->compiled;
        JITTER_BRANCH_AND_LINK_WITH(cc->first_program_point, current_link);
      }
    else
      {
        /* Unfortunately I cannot really tail-call from compiled code to
           interpreted code.  Instead I will call the interpreter as a C
           function and then return. */
        const struct jitterlisp_interpreted_closure *ic = & c->interpreted;

        /* Push an element on the main stack.  This way we can ensure that
           every actual is accessible thru memory in a contiguous array,
           even if the main stack is TOS-optimized.  Compute the address
           (on the main stack backing) where the actuals begin.

           Notice that the interpreted function we are calling is allowed
           to call into compiled code in its turn.  This is not a problem,
           as we are not moving stack pointers down until the call ends:
           the unused part of the main and return stacks is available to
           the callee. */
        JITTER_PUSH_UNSPECIFIED_MAINSTACK();
        jitterlisp_object *actuals
          // FIXME: add a stack operator to compute this address.
          = (& JITTER_UNDER_TOP_MAINSTACK()) - in_arity + 1;

        /* Call the interpreter. */
        jitterlisp_object interpretation_result
          = jitterlisp_call_interpreted (ic, actuals, in_arity);

        /* Remove as many elements as the in-arity plus one (the callee) from
           the stack, without affecting the top.  Unless JITTER_ARGN0 is
           residual this whole loops compiles to one instruction when the main
           stack is TOS-optimized, and doesn't touch memory. */
        int i;
        for (i = 0; i < in_arity + 1; i ++)
          JITTER_NIP_MAINSTACK();

        /* Now the stack is one element higher than it was before the call,
           containing the unspecified element at the top.  Replace it with
           the result.  Again this doesn't touch memory. */
        JITTER_TOP_MAINSTACK() = interpretation_result;

        /* Return to our original caller. */
        jitter_uint return_address = JITTER_TOP_RETURNSTACK();
        JITTER_DROP_RETURNSTACK();
        JITTER_RETURN(return_address);
      }
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for tail-call/n4/retR . */

  //fprintf (stderr, "..Executed instruction %s\n", "tail-call/n4/retR");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the tail-call/n4/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#if    defined(JITTER_DISPATCH_NO_THREADING)         \
    && ! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)
# undef _JITTER_RETURN_ADDRESS
#endif

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(tail-call/n4/retR, tail_mcall__n4__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for tail-call/n4/retR, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction tail-call/n5/retR */
  JITTER_INSTRUCTION_PROLOG_(tail-call/n5/retR, tail_mcall__n5__retR, cold)
  { /* This block begins with definitions for tail-call/n5/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       201
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         tail-call/n5/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "tail-call"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "tail-call/n5/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME tail_mcall__n5__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is a non-replacement and a caller.
       Its 1-th argument, a literal, is the return address where to jump
       back after the procedure returns.  Branch-and-link
       functionality is enabled for this instruction. */
/* This instruction is relocatable: use more efficient branches
   which can generate defects. */
#   undef JITTER_BRANCH_AND_LINK
#   define JITTER_BRANCH_AND_LINK      _JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   define JITTER_BRANCH_AND_LINK_WITH _JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK
#   define JITTER_BRANCH_FAST_AND_LINK _JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is returning, and relocatable. */
#   define JITTER_RETURN  _JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1

    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 5L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1


#if defined(JITTER_DISPATCH_NO_THREADING)             \
    && (! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)  \
        || /* is this a replacement? */ 0)
  /* We use the implicit argument at the end of the calling.
     instruction to discover the procedure return address. */
  const void * const _jitter_return_pointer
    __attribute__ ((unused)) = JITTER_ARGP1;
  /* And make it accessible to the user (who will usually call 
     JITTER_BRANCH_AND_LINK) thru a nice macro. */
# define _JITTER_RETURN_ADDRESS _jitter_return_pointer
#endif

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of tail-call/n5/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "tail-call/n5/retR"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for tail-call/n5/retR . */
  {
/* User-specified code, user code block part: beginning. */

    const jitter_uint in_arity = JITTER_ARGN0;
    jitterlisp_object callee = JITTER_AT_DEPTH_MAINSTACK(in_arity);
    struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(callee);

    if (c->kind == jitterlisp_closure_type_compiled)
      {
        /* Extract the current return address from the return stack, to be
           reused.  Differently from non-tail calls, don't push anything on
           the return stack: the callee will overwrite the top with its
           current value, which is what we want. */
        jitterlispvm_program_point current_link
          = (jitterlispvm_program_point) JITTER_TOP_RETURNSTACK();

        /* Branch-and-relink to the native code, whose first instruction
           will be a prolog. */
        struct jitterlisp_compiled_closure *cc = & c->compiled;
        JITTER_BRANCH_AND_LINK_WITH(cc->first_program_point, current_link);
      }
    else
      {
        /* Unfortunately I cannot really tail-call from compiled code to
           interpreted code.  Instead I will call the interpreter as a C
           function and then return. */
        const struct jitterlisp_interpreted_closure *ic = & c->interpreted;

        /* Push an element on the main stack.  This way we can ensure that
           every actual is accessible thru memory in a contiguous array,
           even if the main stack is TOS-optimized.  Compute the address
           (on the main stack backing) where the actuals begin.

           Notice that the interpreted function we are calling is allowed
           to call into compiled code in its turn.  This is not a problem,
           as we are not moving stack pointers down until the call ends:
           the unused part of the main and return stacks is available to
           the callee. */
        JITTER_PUSH_UNSPECIFIED_MAINSTACK();
        jitterlisp_object *actuals
          // FIXME: add a stack operator to compute this address.
          = (& JITTER_UNDER_TOP_MAINSTACK()) - in_arity + 1;

        /* Call the interpreter. */
        jitterlisp_object interpretation_result
          = jitterlisp_call_interpreted (ic, actuals, in_arity);

        /* Remove as many elements as the in-arity plus one (the callee) from
           the stack, without affecting the top.  Unless JITTER_ARGN0 is
           residual this whole loops compiles to one instruction when the main
           stack is TOS-optimized, and doesn't touch memory. */
        int i;
        for (i = 0; i < in_arity + 1; i ++)
          JITTER_NIP_MAINSTACK();

        /* Now the stack is one element higher than it was before the call,
           containing the unspecified element at the top.  Replace it with
           the result.  Again this doesn't touch memory. */
        JITTER_TOP_MAINSTACK() = interpretation_result;

        /* Return to our original caller. */
        jitter_uint return_address = JITTER_TOP_RETURNSTACK();
        JITTER_DROP_RETURNSTACK();
        JITTER_RETURN(return_address);
      }
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for tail-call/n5/retR . */

  //fprintf (stderr, "..Executed instruction %s\n", "tail-call/n5/retR");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the tail-call/n5/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#if    defined(JITTER_DISPATCH_NO_THREADING)         \
    && ! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)
# undef _JITTER_RETURN_ADDRESS
#endif

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(tail-call/n5/retR, tail_mcall__n5__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for tail-call/n5/retR, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction tail-call/n6/retR */
  JITTER_INSTRUCTION_PROLOG_(tail-call/n6/retR, tail_mcall__n6__retR, cold)
  { /* This block begins with definitions for tail-call/n6/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       202
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         tail-call/n6/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "tail-call"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "tail-call/n6/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME tail_mcall__n6__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is a non-replacement and a caller.
       Its 1-th argument, a literal, is the return address where to jump
       back after the procedure returns.  Branch-and-link
       functionality is enabled for this instruction. */
/* This instruction is relocatable: use more efficient branches
   which can generate defects. */
#   undef JITTER_BRANCH_AND_LINK
#   define JITTER_BRANCH_AND_LINK      _JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   define JITTER_BRANCH_AND_LINK_WITH _JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK
#   define JITTER_BRANCH_FAST_AND_LINK _JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is returning, and relocatable. */
#   define JITTER_RETURN  _JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1

    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 6L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1


#if defined(JITTER_DISPATCH_NO_THREADING)             \
    && (! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)  \
        || /* is this a replacement? */ 0)
  /* We use the implicit argument at the end of the calling.
     instruction to discover the procedure return address. */
  const void * const _jitter_return_pointer
    __attribute__ ((unused)) = JITTER_ARGP1;
  /* And make it accessible to the user (who will usually call 
     JITTER_BRANCH_AND_LINK) thru a nice macro. */
# define _JITTER_RETURN_ADDRESS _jitter_return_pointer
#endif

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of tail-call/n6/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "tail-call/n6/retR"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for tail-call/n6/retR . */
  {
/* User-specified code, user code block part: beginning. */

    const jitter_uint in_arity = JITTER_ARGN0;
    jitterlisp_object callee = JITTER_AT_DEPTH_MAINSTACK(in_arity);
    struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(callee);

    if (c->kind == jitterlisp_closure_type_compiled)
      {
        /* Extract the current return address from the return stack, to be
           reused.  Differently from non-tail calls, don't push anything on
           the return stack: the callee will overwrite the top with its
           current value, which is what we want. */
        jitterlispvm_program_point current_link
          = (jitterlispvm_program_point) JITTER_TOP_RETURNSTACK();

        /* Branch-and-relink to the native code, whose first instruction
           will be a prolog. */
        struct jitterlisp_compiled_closure *cc = & c->compiled;
        JITTER_BRANCH_AND_LINK_WITH(cc->first_program_point, current_link);
      }
    else
      {
        /* Unfortunately I cannot really tail-call from compiled code to
           interpreted code.  Instead I will call the interpreter as a C
           function and then return. */
        const struct jitterlisp_interpreted_closure *ic = & c->interpreted;

        /* Push an element on the main stack.  This way we can ensure that
           every actual is accessible thru memory in a contiguous array,
           even if the main stack is TOS-optimized.  Compute the address
           (on the main stack backing) where the actuals begin.

           Notice that the interpreted function we are calling is allowed
           to call into compiled code in its turn.  This is not a problem,
           as we are not moving stack pointers down until the call ends:
           the unused part of the main and return stacks is available to
           the callee. */
        JITTER_PUSH_UNSPECIFIED_MAINSTACK();
        jitterlisp_object *actuals
          // FIXME: add a stack operator to compute this address.
          = (& JITTER_UNDER_TOP_MAINSTACK()) - in_arity + 1;

        /* Call the interpreter. */
        jitterlisp_object interpretation_result
          = jitterlisp_call_interpreted (ic, actuals, in_arity);

        /* Remove as many elements as the in-arity plus one (the callee) from
           the stack, without affecting the top.  Unless JITTER_ARGN0 is
           residual this whole loops compiles to one instruction when the main
           stack is TOS-optimized, and doesn't touch memory. */
        int i;
        for (i = 0; i < in_arity + 1; i ++)
          JITTER_NIP_MAINSTACK();

        /* Now the stack is one element higher than it was before the call,
           containing the unspecified element at the top.  Replace it with
           the result.  Again this doesn't touch memory. */
        JITTER_TOP_MAINSTACK() = interpretation_result;

        /* Return to our original caller. */
        jitter_uint return_address = JITTER_TOP_RETURNSTACK();
        JITTER_DROP_RETURNSTACK();
        JITTER_RETURN(return_address);
      }
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for tail-call/n6/retR . */

  //fprintf (stderr, "..Executed instruction %s\n", "tail-call/n6/retR");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the tail-call/n6/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#if    defined(JITTER_DISPATCH_NO_THREADING)         \
    && ! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)
# undef _JITTER_RETURN_ADDRESS
#endif

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(tail-call/n6/retR, tail_mcall__n6__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for tail-call/n6/retR, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction tail-call/n7/retR */
  JITTER_INSTRUCTION_PROLOG_(tail-call/n7/retR, tail_mcall__n7__retR, cold)
  { /* This block begins with definitions for tail-call/n7/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       203
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         tail-call/n7/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "tail-call"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "tail-call/n7/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME tail_mcall__n7__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is a non-replacement and a caller.
       Its 1-th argument, a literal, is the return address where to jump
       back after the procedure returns.  Branch-and-link
       functionality is enabled for this instruction. */
/* This instruction is relocatable: use more efficient branches
   which can generate defects. */
#   undef JITTER_BRANCH_AND_LINK
#   define JITTER_BRANCH_AND_LINK      _JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   define JITTER_BRANCH_AND_LINK_WITH _JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK
#   define JITTER_BRANCH_FAST_AND_LINK _JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is returning, and relocatable. */
#   define JITTER_RETURN  _JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1

    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 7L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1


#if defined(JITTER_DISPATCH_NO_THREADING)             \
    && (! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)  \
        || /* is this a replacement? */ 0)
  /* We use the implicit argument at the end of the calling.
     instruction to discover the procedure return address. */
  const void * const _jitter_return_pointer
    __attribute__ ((unused)) = JITTER_ARGP1;
  /* And make it accessible to the user (who will usually call 
     JITTER_BRANCH_AND_LINK) thru a nice macro. */
# define _JITTER_RETURN_ADDRESS _jitter_return_pointer
#endif

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of tail-call/n7/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "tail-call/n7/retR"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for tail-call/n7/retR . */
  {
/* User-specified code, user code block part: beginning. */

    const jitter_uint in_arity = JITTER_ARGN0;
    jitterlisp_object callee = JITTER_AT_DEPTH_MAINSTACK(in_arity);
    struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(callee);

    if (c->kind == jitterlisp_closure_type_compiled)
      {
        /* Extract the current return address from the return stack, to be
           reused.  Differently from non-tail calls, don't push anything on
           the return stack: the callee will overwrite the top with its
           current value, which is what we want. */
        jitterlispvm_program_point current_link
          = (jitterlispvm_program_point) JITTER_TOP_RETURNSTACK();

        /* Branch-and-relink to the native code, whose first instruction
           will be a prolog. */
        struct jitterlisp_compiled_closure *cc = & c->compiled;
        JITTER_BRANCH_AND_LINK_WITH(cc->first_program_point, current_link);
      }
    else
      {
        /* Unfortunately I cannot really tail-call from compiled code to
           interpreted code.  Instead I will call the interpreter as a C
           function and then return. */
        const struct jitterlisp_interpreted_closure *ic = & c->interpreted;

        /* Push an element on the main stack.  This way we can ensure that
           every actual is accessible thru memory in a contiguous array,
           even if the main stack is TOS-optimized.  Compute the address
           (on the main stack backing) where the actuals begin.

           Notice that the interpreted function we are calling is allowed
           to call into compiled code in its turn.  This is not a problem,
           as we are not moving stack pointers down until the call ends:
           the unused part of the main and return stacks is available to
           the callee. */
        JITTER_PUSH_UNSPECIFIED_MAINSTACK();
        jitterlisp_object *actuals
          // FIXME: add a stack operator to compute this address.
          = (& JITTER_UNDER_TOP_MAINSTACK()) - in_arity + 1;

        /* Call the interpreter. */
        jitterlisp_object interpretation_result
          = jitterlisp_call_interpreted (ic, actuals, in_arity);

        /* Remove as many elements as the in-arity plus one (the callee) from
           the stack, without affecting the top.  Unless JITTER_ARGN0 is
           residual this whole loops compiles to one instruction when the main
           stack is TOS-optimized, and doesn't touch memory. */
        int i;
        for (i = 0; i < in_arity + 1; i ++)
          JITTER_NIP_MAINSTACK();

        /* Now the stack is one element higher than it was before the call,
           containing the unspecified element at the top.  Replace it with
           the result.  Again this doesn't touch memory. */
        JITTER_TOP_MAINSTACK() = interpretation_result;

        /* Return to our original caller. */
        jitter_uint return_address = JITTER_TOP_RETURNSTACK();
        JITTER_DROP_RETURNSTACK();
        JITTER_RETURN(return_address);
      }
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for tail-call/n7/retR . */

  //fprintf (stderr, "..Executed instruction %s\n", "tail-call/n7/retR");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the tail-call/n7/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#if    defined(JITTER_DISPATCH_NO_THREADING)         \
    && ! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)
# undef _JITTER_RETURN_ADDRESS
#endif

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(tail-call/n7/retR, tail_mcall__n7__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for tail-call/n7/retR, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction tail-call/n8/retR */
  JITTER_INSTRUCTION_PROLOG_(tail-call/n8/retR, tail_mcall__n8__retR, cold)
  { /* This block begins with definitions for tail-call/n8/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       204
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         tail-call/n8/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "tail-call"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "tail-call/n8/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME tail_mcall__n8__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is a non-replacement and a caller.
       Its 1-th argument, a literal, is the return address where to jump
       back after the procedure returns.  Branch-and-link
       functionality is enabled for this instruction. */
/* This instruction is relocatable: use more efficient branches
   which can generate defects. */
#   undef JITTER_BRANCH_AND_LINK
#   define JITTER_BRANCH_AND_LINK      _JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   define JITTER_BRANCH_AND_LINK_WITH _JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK
#   define JITTER_BRANCH_FAST_AND_LINK _JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is returning, and relocatable. */
#   define JITTER_RETURN  _JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1

    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 8L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1


#if defined(JITTER_DISPATCH_NO_THREADING)             \
    && (! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)  \
        || /* is this a replacement? */ 0)
  /* We use the implicit argument at the end of the calling.
     instruction to discover the procedure return address. */
  const void * const _jitter_return_pointer
    __attribute__ ((unused)) = JITTER_ARGP1;
  /* And make it accessible to the user (who will usually call 
     JITTER_BRANCH_AND_LINK) thru a nice macro. */
# define _JITTER_RETURN_ADDRESS _jitter_return_pointer
#endif

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of tail-call/n8/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "tail-call/n8/retR"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for tail-call/n8/retR . */
  {
/* User-specified code, user code block part: beginning. */

    const jitter_uint in_arity = JITTER_ARGN0;
    jitterlisp_object callee = JITTER_AT_DEPTH_MAINSTACK(in_arity);
    struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(callee);

    if (c->kind == jitterlisp_closure_type_compiled)
      {
        /* Extract the current return address from the return stack, to be
           reused.  Differently from non-tail calls, don't push anything on
           the return stack: the callee will overwrite the top with its
           current value, which is what we want. */
        jitterlispvm_program_point current_link
          = (jitterlispvm_program_point) JITTER_TOP_RETURNSTACK();

        /* Branch-and-relink to the native code, whose first instruction
           will be a prolog. */
        struct jitterlisp_compiled_closure *cc = & c->compiled;
        JITTER_BRANCH_AND_LINK_WITH(cc->first_program_point, current_link);
      }
    else
      {
        /* Unfortunately I cannot really tail-call from compiled code to
           interpreted code.  Instead I will call the interpreter as a C
           function and then return. */
        const struct jitterlisp_interpreted_closure *ic = & c->interpreted;

        /* Push an element on the main stack.  This way we can ensure that
           every actual is accessible thru memory in a contiguous array,
           even if the main stack is TOS-optimized.  Compute the address
           (on the main stack backing) where the actuals begin.

           Notice that the interpreted function we are calling is allowed
           to call into compiled code in its turn.  This is not a problem,
           as we are not moving stack pointers down until the call ends:
           the unused part of the main and return stacks is available to
           the callee. */
        JITTER_PUSH_UNSPECIFIED_MAINSTACK();
        jitterlisp_object *actuals
          // FIXME: add a stack operator to compute this address.
          = (& JITTER_UNDER_TOP_MAINSTACK()) - in_arity + 1;

        /* Call the interpreter. */
        jitterlisp_object interpretation_result
          = jitterlisp_call_interpreted (ic, actuals, in_arity);

        /* Remove as many elements as the in-arity plus one (the callee) from
           the stack, without affecting the top.  Unless JITTER_ARGN0 is
           residual this whole loops compiles to one instruction when the main
           stack is TOS-optimized, and doesn't touch memory. */
        int i;
        for (i = 0; i < in_arity + 1; i ++)
          JITTER_NIP_MAINSTACK();

        /* Now the stack is one element higher than it was before the call,
           containing the unspecified element at the top.  Replace it with
           the result.  Again this doesn't touch memory. */
        JITTER_TOP_MAINSTACK() = interpretation_result;

        /* Return to our original caller. */
        jitter_uint return_address = JITTER_TOP_RETURNSTACK();
        JITTER_DROP_RETURNSTACK();
        JITTER_RETURN(return_address);
      }
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for tail-call/n8/retR . */

  //fprintf (stderr, "..Executed instruction %s\n", "tail-call/n8/retR");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the tail-call/n8/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#if    defined(JITTER_DISPATCH_NO_THREADING)         \
    && ! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)
# undef _JITTER_RETURN_ADDRESS
#endif

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(tail-call/n8/retR, tail_mcall__n8__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for tail-call/n8/retR, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction tail-call/n9/retR */
  JITTER_INSTRUCTION_PROLOG_(tail-call/n9/retR, tail_mcall__n9__retR, cold)
  { /* This block begins with definitions for tail-call/n9/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       205
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         tail-call/n9/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "tail-call"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "tail-call/n9/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME tail_mcall__n9__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is a non-replacement and a caller.
       Its 1-th argument, a literal, is the return address where to jump
       back after the procedure returns.  Branch-and-link
       functionality is enabled for this instruction. */
/* This instruction is relocatable: use more efficient branches
   which can generate defects. */
#   undef JITTER_BRANCH_AND_LINK
#   define JITTER_BRANCH_AND_LINK      _JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   define JITTER_BRANCH_AND_LINK_WITH _JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK
#   define JITTER_BRANCH_FAST_AND_LINK _JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is returning, and relocatable. */
#   define JITTER_RETURN  _JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1

    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 9L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1


#if defined(JITTER_DISPATCH_NO_THREADING)             \
    && (! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)  \
        || /* is this a replacement? */ 0)
  /* We use the implicit argument at the end of the calling.
     instruction to discover the procedure return address. */
  const void * const _jitter_return_pointer
    __attribute__ ((unused)) = JITTER_ARGP1;
  /* And make it accessible to the user (who will usually call 
     JITTER_BRANCH_AND_LINK) thru a nice macro. */
# define _JITTER_RETURN_ADDRESS _jitter_return_pointer
#endif

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of tail-call/n9/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "tail-call/n9/retR"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for tail-call/n9/retR . */
  {
/* User-specified code, user code block part: beginning. */

    const jitter_uint in_arity = JITTER_ARGN0;
    jitterlisp_object callee = JITTER_AT_DEPTH_MAINSTACK(in_arity);
    struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(callee);

    if (c->kind == jitterlisp_closure_type_compiled)
      {
        /* Extract the current return address from the return stack, to be
           reused.  Differently from non-tail calls, don't push anything on
           the return stack: the callee will overwrite the top with its
           current value, which is what we want. */
        jitterlispvm_program_point current_link
          = (jitterlispvm_program_point) JITTER_TOP_RETURNSTACK();

        /* Branch-and-relink to the native code, whose first instruction
           will be a prolog. */
        struct jitterlisp_compiled_closure *cc = & c->compiled;
        JITTER_BRANCH_AND_LINK_WITH(cc->first_program_point, current_link);
      }
    else
      {
        /* Unfortunately I cannot really tail-call from compiled code to
           interpreted code.  Instead I will call the interpreter as a C
           function and then return. */
        const struct jitterlisp_interpreted_closure *ic = & c->interpreted;

        /* Push an element on the main stack.  This way we can ensure that
           every actual is accessible thru memory in a contiguous array,
           even if the main stack is TOS-optimized.  Compute the address
           (on the main stack backing) where the actuals begin.

           Notice that the interpreted function we are calling is allowed
           to call into compiled code in its turn.  This is not a problem,
           as we are not moving stack pointers down until the call ends:
           the unused part of the main and return stacks is available to
           the callee. */
        JITTER_PUSH_UNSPECIFIED_MAINSTACK();
        jitterlisp_object *actuals
          // FIXME: add a stack operator to compute this address.
          = (& JITTER_UNDER_TOP_MAINSTACK()) - in_arity + 1;

        /* Call the interpreter. */
        jitterlisp_object interpretation_result
          = jitterlisp_call_interpreted (ic, actuals, in_arity);

        /* Remove as many elements as the in-arity plus one (the callee) from
           the stack, without affecting the top.  Unless JITTER_ARGN0 is
           residual this whole loops compiles to one instruction when the main
           stack is TOS-optimized, and doesn't touch memory. */
        int i;
        for (i = 0; i < in_arity + 1; i ++)
          JITTER_NIP_MAINSTACK();

        /* Now the stack is one element higher than it was before the call,
           containing the unspecified element at the top.  Replace it with
           the result.  Again this doesn't touch memory. */
        JITTER_TOP_MAINSTACK() = interpretation_result;

        /* Return to our original caller. */
        jitter_uint return_address = JITTER_TOP_RETURNSTACK();
        JITTER_DROP_RETURNSTACK();
        JITTER_RETURN(return_address);
      }
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for tail-call/n9/retR . */

  //fprintf (stderr, "..Executed instruction %s\n", "tail-call/n9/retR");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the tail-call/n9/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#if    defined(JITTER_DISPATCH_NO_THREADING)         \
    && ! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)
# undef _JITTER_RETURN_ADDRESS
#endif

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(tail-call/n9/retR, tail_mcall__n9__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for tail-call/n9/retR, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction tail-call/n10/retR */
  JITTER_INSTRUCTION_PROLOG_(tail-call/n10/retR, tail_mcall__n10__retR, cold)
  { /* This block begins with definitions for tail-call/n10/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       206
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         tail-call/n10/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "tail-call"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "tail-call/n10/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME tail_mcall__n10__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is a non-replacement and a caller.
       Its 1-th argument, a literal, is the return address where to jump
       back after the procedure returns.  Branch-and-link
       functionality is enabled for this instruction. */
/* This instruction is relocatable: use more efficient branches
   which can generate defects. */
#   undef JITTER_BRANCH_AND_LINK
#   define JITTER_BRANCH_AND_LINK      _JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   define JITTER_BRANCH_AND_LINK_WITH _JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK
#   define JITTER_BRANCH_FAST_AND_LINK _JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is returning, and relocatable. */
#   define JITTER_RETURN  _JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1

    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 10L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1


#if defined(JITTER_DISPATCH_NO_THREADING)             \
    && (! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)  \
        || /* is this a replacement? */ 0)
  /* We use the implicit argument at the end of the calling.
     instruction to discover the procedure return address. */
  const void * const _jitter_return_pointer
    __attribute__ ((unused)) = JITTER_ARGP1;
  /* And make it accessible to the user (who will usually call 
     JITTER_BRANCH_AND_LINK) thru a nice macro. */
# define _JITTER_RETURN_ADDRESS _jitter_return_pointer
#endif

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of tail-call/n10/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "tail-call/n10/retR"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for tail-call/n10/retR . */
  {
/* User-specified code, user code block part: beginning. */

    const jitter_uint in_arity = JITTER_ARGN0;
    jitterlisp_object callee = JITTER_AT_DEPTH_MAINSTACK(in_arity);
    struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(callee);

    if (c->kind == jitterlisp_closure_type_compiled)
      {
        /* Extract the current return address from the return stack, to be
           reused.  Differently from non-tail calls, don't push anything on
           the return stack: the callee will overwrite the top with its
           current value, which is what we want. */
        jitterlispvm_program_point current_link
          = (jitterlispvm_program_point) JITTER_TOP_RETURNSTACK();

        /* Branch-and-relink to the native code, whose first instruction
           will be a prolog. */
        struct jitterlisp_compiled_closure *cc = & c->compiled;
        JITTER_BRANCH_AND_LINK_WITH(cc->first_program_point, current_link);
      }
    else
      {
        /* Unfortunately I cannot really tail-call from compiled code to
           interpreted code.  Instead I will call the interpreter as a C
           function and then return. */
        const struct jitterlisp_interpreted_closure *ic = & c->interpreted;

        /* Push an element on the main stack.  This way we can ensure that
           every actual is accessible thru memory in a contiguous array,
           even if the main stack is TOS-optimized.  Compute the address
           (on the main stack backing) where the actuals begin.

           Notice that the interpreted function we are calling is allowed
           to call into compiled code in its turn.  This is not a problem,
           as we are not moving stack pointers down until the call ends:
           the unused part of the main and return stacks is available to
           the callee. */
        JITTER_PUSH_UNSPECIFIED_MAINSTACK();
        jitterlisp_object *actuals
          // FIXME: add a stack operator to compute this address.
          = (& JITTER_UNDER_TOP_MAINSTACK()) - in_arity + 1;

        /* Call the interpreter. */
        jitterlisp_object interpretation_result
          = jitterlisp_call_interpreted (ic, actuals, in_arity);

        /* Remove as many elements as the in-arity plus one (the callee) from
           the stack, without affecting the top.  Unless JITTER_ARGN0 is
           residual this whole loops compiles to one instruction when the main
           stack is TOS-optimized, and doesn't touch memory. */
        int i;
        for (i = 0; i < in_arity + 1; i ++)
          JITTER_NIP_MAINSTACK();

        /* Now the stack is one element higher than it was before the call,
           containing the unspecified element at the top.  Replace it with
           the result.  Again this doesn't touch memory. */
        JITTER_TOP_MAINSTACK() = interpretation_result;

        /* Return to our original caller. */
        jitter_uint return_address = JITTER_TOP_RETURNSTACK();
        JITTER_DROP_RETURNSTACK();
        JITTER_RETURN(return_address);
      }
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for tail-call/n10/retR . */

  //fprintf (stderr, "..Executed instruction %s\n", "tail-call/n10/retR");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the tail-call/n10/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#if    defined(JITTER_DISPATCH_NO_THREADING)         \
    && ! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)
# undef _JITTER_RETURN_ADDRESS
#endif

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(tail-call/n10/retR, tail_mcall__n10__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for tail-call/n10/retR, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction tail-call/nR/retR */
  JITTER_INSTRUCTION_PROLOG_(tail-call/nR/retR, tail_mcall__nR__retR, cold)
  { /* This block begins with definitions for tail-call/nR/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       207
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         tail-call/nR/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "tail-call"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "tail-call/nR/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME tail_mcall__nR__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is a non-replacement and a caller.
       Its 1-th argument, a literal, is the return address where to jump
       back after the procedure returns.  Branch-and-link
       functionality is enabled for this instruction. */
/* This instruction is relocatable: use more efficient branches
   which can generate defects. */
#   undef JITTER_BRANCH_AND_LINK
#   define JITTER_BRANCH_AND_LINK      _JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   define JITTER_BRANCH_AND_LINK_WITH _JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK
#   define JITTER_BRANCH_FAST_AND_LINK _JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is returning, and relocatable. */
#   define JITTER_RETURN  _JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 2

    /* The 0th argument is a residual literal. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1


#if defined(JITTER_DISPATCH_NO_THREADING)             \
    && (! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)  \
        || /* is this a replacement? */ 0)
  /* We use the implicit argument at the end of the calling.
     instruction to discover the procedure return address. */
  const void * const _jitter_return_pointer
    __attribute__ ((unused)) = JITTER_ARGP1;
  /* And make it accessible to the user (who will usually call 
     JITTER_BRANCH_AND_LINK) thru a nice macro. */
# define _JITTER_RETURN_ADDRESS _jitter_return_pointer
#endif

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of tail-call/nR/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "tail-call/nR/retR"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for tail-call/nR/retR . */
  {
/* User-specified code, user code block part: beginning. */

    const jitter_uint in_arity = JITTER_ARGN0;
    jitterlisp_object callee = JITTER_AT_DEPTH_MAINSTACK(in_arity);
    struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(callee);

    if (c->kind == jitterlisp_closure_type_compiled)
      {
        /* Extract the current return address from the return stack, to be
           reused.  Differently from non-tail calls, don't push anything on
           the return stack: the callee will overwrite the top with its
           current value, which is what we want. */
        jitterlispvm_program_point current_link
          = (jitterlispvm_program_point) JITTER_TOP_RETURNSTACK();

        /* Branch-and-relink to the native code, whose first instruction
           will be a prolog. */
        struct jitterlisp_compiled_closure *cc = & c->compiled;
        JITTER_BRANCH_AND_LINK_WITH(cc->first_program_point, current_link);
      }
    else
      {
        /* Unfortunately I cannot really tail-call from compiled code to
           interpreted code.  Instead I will call the interpreter as a C
           function and then return. */
        const struct jitterlisp_interpreted_closure *ic = & c->interpreted;

        /* Push an element on the main stack.  This way we can ensure that
           every actual is accessible thru memory in a contiguous array,
           even if the main stack is TOS-optimized.  Compute the address
           (on the main stack backing) where the actuals begin.

           Notice that the interpreted function we are calling is allowed
           to call into compiled code in its turn.  This is not a problem,
           as we are not moving stack pointers down until the call ends:
           the unused part of the main and return stacks is available to
           the callee. */
        JITTER_PUSH_UNSPECIFIED_MAINSTACK();
        jitterlisp_object *actuals
          // FIXME: add a stack operator to compute this address.
          = (& JITTER_UNDER_TOP_MAINSTACK()) - in_arity + 1;

        /* Call the interpreter. */
        jitterlisp_object interpretation_result
          = jitterlisp_call_interpreted (ic, actuals, in_arity);

        /* Remove as many elements as the in-arity plus one (the callee) from
           the stack, without affecting the top.  Unless JITTER_ARGN0 is
           residual this whole loops compiles to one instruction when the main
           stack is TOS-optimized, and doesn't touch memory. */
        int i;
        for (i = 0; i < in_arity + 1; i ++)
          JITTER_NIP_MAINSTACK();

        /* Now the stack is one element higher than it was before the call,
           containing the unspecified element at the top.  Replace it with
           the result.  Again this doesn't touch memory. */
        JITTER_TOP_MAINSTACK() = interpretation_result;

        /* Return to our original caller. */
        jitter_uint return_address = JITTER_TOP_RETURNSTACK();
        JITTER_DROP_RETURNSTACK();
        JITTER_RETURN(return_address);
      }
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for tail-call/nR/retR . */

  //fprintf (stderr, "..Executed instruction %s\n", "tail-call/nR/retR");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the tail-call/nR/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#if    defined(JITTER_DISPATCH_NO_THREADING)         \
    && ! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)
# undef _JITTER_RETURN_ADDRESS
#endif

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(tail-call/nR/retR, tail_mcall__nR__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for tail-call/nR/retR, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction tail-call-compiled/n0/retR */
  JITTER_INSTRUCTION_PROLOG_(tail-call-compiled/n0/retR, tail_mcall_mcompiled__n0__retR, cold)
  { /* This block begins with definitions for tail-call-compiled/n0/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       208
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         tail-call-compiled/n0/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "tail-call-compiled"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "tail-call-compiled/n0/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME tail_mcall_mcompiled__n0__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is a non-replacement and a caller.
       Its 1-th argument, a literal, is the return address where to jump
       back after the procedure returns.  Branch-and-link
       functionality is enabled for this instruction. */
/* This instruction is relocatable: use more efficient branches
   which can generate defects. */
#   undef JITTER_BRANCH_AND_LINK
#   define JITTER_BRANCH_AND_LINK      _JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   define JITTER_BRANCH_AND_LINK_WITH _JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK
#   define JITTER_BRANCH_FAST_AND_LINK _JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1

    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 0L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1


#if defined(JITTER_DISPATCH_NO_THREADING)             \
    && (! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)  \
        || /* is this a replacement? */ 0)
  /* We use the implicit argument at the end of the calling.
     instruction to discover the procedure return address. */
  const void * const _jitter_return_pointer
    __attribute__ ((unused)) = JITTER_ARGP1;
  /* And make it accessible to the user (who will usually call 
     JITTER_BRANCH_AND_LINK) thru a nice macro. */
# define _JITTER_RETURN_ADDRESS _jitter_return_pointer
#endif

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of tail-call-compiled/n0/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "tail-call-compiled/n0/retR"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for tail-call-compiled/n0/retR . */
  {
/* User-specified code, user code block part: beginning. */

    const jitter_uint in_arity = JITTER_ARGN0;
    jitterlisp_object callee = JITTER_AT_DEPTH_MAINSTACK(in_arity);
    struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(callee);

    /* Here we can assume that * c is a compiled closure without checking. */
    struct jitterlisp_compiled_closure *cc = & c->compiled;

    /* Take the current return address from the return stack: I want to keep
       returning there.  Differently from the case of non-tail calls I don't
       push anything on the return stack: the callee prolog will overwrite
       the current top with a copy of itself, which is fine. */
    jitterlispvm_program_point current_link
      = (jitterlispvm_program_point) JITTER_TOP_RETURNSTACK();

    /* Branch-and-relink to the native code, whose first instruction
       will be a prolog. */
    JITTER_BRANCH_AND_LINK_WITH(cc->first_program_point, current_link);
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for tail-call-compiled/n0/retR . */

  //fprintf (stderr, "..Executed instruction %s\n", "tail-call-compiled/n0/retR");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the tail-call-compiled/n0/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#if    defined(JITTER_DISPATCH_NO_THREADING)         \
    && ! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)
# undef _JITTER_RETURN_ADDRESS
#endif

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(tail-call-compiled/n0/retR, tail_mcall_mcompiled__n0__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for tail-call-compiled/n0/retR, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction tail-call-compiled/n1/retR */
  JITTER_INSTRUCTION_PROLOG_(tail-call-compiled/n1/retR, tail_mcall_mcompiled__n1__retR, cold)
  { /* This block begins with definitions for tail-call-compiled/n1/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       209
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         tail-call-compiled/n1/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "tail-call-compiled"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "tail-call-compiled/n1/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME tail_mcall_mcompiled__n1__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is a non-replacement and a caller.
       Its 1-th argument, a literal, is the return address where to jump
       back after the procedure returns.  Branch-and-link
       functionality is enabled for this instruction. */
/* This instruction is relocatable: use more efficient branches
   which can generate defects. */
#   undef JITTER_BRANCH_AND_LINK
#   define JITTER_BRANCH_AND_LINK      _JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   define JITTER_BRANCH_AND_LINK_WITH _JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK
#   define JITTER_BRANCH_FAST_AND_LINK _JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1

    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 1L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1


#if defined(JITTER_DISPATCH_NO_THREADING)             \
    && (! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)  \
        || /* is this a replacement? */ 0)
  /* We use the implicit argument at the end of the calling.
     instruction to discover the procedure return address. */
  const void * const _jitter_return_pointer
    __attribute__ ((unused)) = JITTER_ARGP1;
  /* And make it accessible to the user (who will usually call 
     JITTER_BRANCH_AND_LINK) thru a nice macro. */
# define _JITTER_RETURN_ADDRESS _jitter_return_pointer
#endif

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of tail-call-compiled/n1/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "tail-call-compiled/n1/retR"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for tail-call-compiled/n1/retR . */
  {
/* User-specified code, user code block part: beginning. */

    const jitter_uint in_arity = JITTER_ARGN0;
    jitterlisp_object callee = JITTER_AT_DEPTH_MAINSTACK(in_arity);
    struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(callee);

    /* Here we can assume that * c is a compiled closure without checking. */
    struct jitterlisp_compiled_closure *cc = & c->compiled;

    /* Take the current return address from the return stack: I want to keep
       returning there.  Differently from the case of non-tail calls I don't
       push anything on the return stack: the callee prolog will overwrite
       the current top with a copy of itself, which is fine. */
    jitterlispvm_program_point current_link
      = (jitterlispvm_program_point) JITTER_TOP_RETURNSTACK();

    /* Branch-and-relink to the native code, whose first instruction
       will be a prolog. */
    JITTER_BRANCH_AND_LINK_WITH(cc->first_program_point, current_link);
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for tail-call-compiled/n1/retR . */

  //fprintf (stderr, "..Executed instruction %s\n", "tail-call-compiled/n1/retR");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the tail-call-compiled/n1/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#if    defined(JITTER_DISPATCH_NO_THREADING)         \
    && ! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)
# undef _JITTER_RETURN_ADDRESS
#endif

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(tail-call-compiled/n1/retR, tail_mcall_mcompiled__n1__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for tail-call-compiled/n1/retR, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction tail-call-compiled/n2/retR */
  JITTER_INSTRUCTION_PROLOG_(tail-call-compiled/n2/retR, tail_mcall_mcompiled__n2__retR, cold)
  { /* This block begins with definitions for tail-call-compiled/n2/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       210
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         tail-call-compiled/n2/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "tail-call-compiled"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "tail-call-compiled/n2/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME tail_mcall_mcompiled__n2__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is a non-replacement and a caller.
       Its 1-th argument, a literal, is the return address where to jump
       back after the procedure returns.  Branch-and-link
       functionality is enabled for this instruction. */
/* This instruction is relocatable: use more efficient branches
   which can generate defects. */
#   undef JITTER_BRANCH_AND_LINK
#   define JITTER_BRANCH_AND_LINK      _JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   define JITTER_BRANCH_AND_LINK_WITH _JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK
#   define JITTER_BRANCH_FAST_AND_LINK _JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1

    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 2L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1


#if defined(JITTER_DISPATCH_NO_THREADING)             \
    && (! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)  \
        || /* is this a replacement? */ 0)
  /* We use the implicit argument at the end of the calling.
     instruction to discover the procedure return address. */
  const void * const _jitter_return_pointer
    __attribute__ ((unused)) = JITTER_ARGP1;
  /* And make it accessible to the user (who will usually call 
     JITTER_BRANCH_AND_LINK) thru a nice macro. */
# define _JITTER_RETURN_ADDRESS _jitter_return_pointer
#endif

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of tail-call-compiled/n2/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "tail-call-compiled/n2/retR"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for tail-call-compiled/n2/retR . */
  {
/* User-specified code, user code block part: beginning. */

    const jitter_uint in_arity = JITTER_ARGN0;
    jitterlisp_object callee = JITTER_AT_DEPTH_MAINSTACK(in_arity);
    struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(callee);

    /* Here we can assume that * c is a compiled closure without checking. */
    struct jitterlisp_compiled_closure *cc = & c->compiled;

    /* Take the current return address from the return stack: I want to keep
       returning there.  Differently from the case of non-tail calls I don't
       push anything on the return stack: the callee prolog will overwrite
       the current top with a copy of itself, which is fine. */
    jitterlispvm_program_point current_link
      = (jitterlispvm_program_point) JITTER_TOP_RETURNSTACK();

    /* Branch-and-relink to the native code, whose first instruction
       will be a prolog. */
    JITTER_BRANCH_AND_LINK_WITH(cc->first_program_point, current_link);
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for tail-call-compiled/n2/retR . */

  //fprintf (stderr, "..Executed instruction %s\n", "tail-call-compiled/n2/retR");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the tail-call-compiled/n2/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#if    defined(JITTER_DISPATCH_NO_THREADING)         \
    && ! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)
# undef _JITTER_RETURN_ADDRESS
#endif

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(tail-call-compiled/n2/retR, tail_mcall_mcompiled__n2__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for tail-call-compiled/n2/retR, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction tail-call-compiled/n3/retR */
  JITTER_INSTRUCTION_PROLOG_(tail-call-compiled/n3/retR, tail_mcall_mcompiled__n3__retR, cold)
  { /* This block begins with definitions for tail-call-compiled/n3/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       211
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         tail-call-compiled/n3/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "tail-call-compiled"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "tail-call-compiled/n3/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME tail_mcall_mcompiled__n3__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is a non-replacement and a caller.
       Its 1-th argument, a literal, is the return address where to jump
       back after the procedure returns.  Branch-and-link
       functionality is enabled for this instruction. */
/* This instruction is relocatable: use more efficient branches
   which can generate defects. */
#   undef JITTER_BRANCH_AND_LINK
#   define JITTER_BRANCH_AND_LINK      _JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   define JITTER_BRANCH_AND_LINK_WITH _JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK
#   define JITTER_BRANCH_FAST_AND_LINK _JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1

    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 3L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1


#if defined(JITTER_DISPATCH_NO_THREADING)             \
    && (! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)  \
        || /* is this a replacement? */ 0)
  /* We use the implicit argument at the end of the calling.
     instruction to discover the procedure return address. */
  const void * const _jitter_return_pointer
    __attribute__ ((unused)) = JITTER_ARGP1;
  /* And make it accessible to the user (who will usually call 
     JITTER_BRANCH_AND_LINK) thru a nice macro. */
# define _JITTER_RETURN_ADDRESS _jitter_return_pointer
#endif

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of tail-call-compiled/n3/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "tail-call-compiled/n3/retR"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for tail-call-compiled/n3/retR . */
  {
/* User-specified code, user code block part: beginning. */

    const jitter_uint in_arity = JITTER_ARGN0;
    jitterlisp_object callee = JITTER_AT_DEPTH_MAINSTACK(in_arity);
    struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(callee);

    /* Here we can assume that * c is a compiled closure without checking. */
    struct jitterlisp_compiled_closure *cc = & c->compiled;

    /* Take the current return address from the return stack: I want to keep
       returning there.  Differently from the case of non-tail calls I don't
       push anything on the return stack: the callee prolog will overwrite
       the current top with a copy of itself, which is fine. */
    jitterlispvm_program_point current_link
      = (jitterlispvm_program_point) JITTER_TOP_RETURNSTACK();

    /* Branch-and-relink to the native code, whose first instruction
       will be a prolog. */
    JITTER_BRANCH_AND_LINK_WITH(cc->first_program_point, current_link);
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for tail-call-compiled/n3/retR . */

  //fprintf (stderr, "..Executed instruction %s\n", "tail-call-compiled/n3/retR");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the tail-call-compiled/n3/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#if    defined(JITTER_DISPATCH_NO_THREADING)         \
    && ! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)
# undef _JITTER_RETURN_ADDRESS
#endif

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(tail-call-compiled/n3/retR, tail_mcall_mcompiled__n3__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for tail-call-compiled/n3/retR, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction tail-call-compiled/n4/retR */
  JITTER_INSTRUCTION_PROLOG_(tail-call-compiled/n4/retR, tail_mcall_mcompiled__n4__retR, cold)
  { /* This block begins with definitions for tail-call-compiled/n4/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       212
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         tail-call-compiled/n4/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "tail-call-compiled"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "tail-call-compiled/n4/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME tail_mcall_mcompiled__n4__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is a non-replacement and a caller.
       Its 1-th argument, a literal, is the return address where to jump
       back after the procedure returns.  Branch-and-link
       functionality is enabled for this instruction. */
/* This instruction is relocatable: use more efficient branches
   which can generate defects. */
#   undef JITTER_BRANCH_AND_LINK
#   define JITTER_BRANCH_AND_LINK      _JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   define JITTER_BRANCH_AND_LINK_WITH _JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK
#   define JITTER_BRANCH_FAST_AND_LINK _JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1

    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 4L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1


#if defined(JITTER_DISPATCH_NO_THREADING)             \
    && (! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)  \
        || /* is this a replacement? */ 0)
  /* We use the implicit argument at the end of the calling.
     instruction to discover the procedure return address. */
  const void * const _jitter_return_pointer
    __attribute__ ((unused)) = JITTER_ARGP1;
  /* And make it accessible to the user (who will usually call 
     JITTER_BRANCH_AND_LINK) thru a nice macro. */
# define _JITTER_RETURN_ADDRESS _jitter_return_pointer
#endif

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of tail-call-compiled/n4/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "tail-call-compiled/n4/retR"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for tail-call-compiled/n4/retR . */
  {
/* User-specified code, user code block part: beginning. */

    const jitter_uint in_arity = JITTER_ARGN0;
    jitterlisp_object callee = JITTER_AT_DEPTH_MAINSTACK(in_arity);
    struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(callee);

    /* Here we can assume that * c is a compiled closure without checking. */
    struct jitterlisp_compiled_closure *cc = & c->compiled;

    /* Take the current return address from the return stack: I want to keep
       returning there.  Differently from the case of non-tail calls I don't
       push anything on the return stack: the callee prolog will overwrite
       the current top with a copy of itself, which is fine. */
    jitterlispvm_program_point current_link
      = (jitterlispvm_program_point) JITTER_TOP_RETURNSTACK();

    /* Branch-and-relink to the native code, whose first instruction
       will be a prolog. */
    JITTER_BRANCH_AND_LINK_WITH(cc->first_program_point, current_link);
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for tail-call-compiled/n4/retR . */

  //fprintf (stderr, "..Executed instruction %s\n", "tail-call-compiled/n4/retR");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the tail-call-compiled/n4/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#if    defined(JITTER_DISPATCH_NO_THREADING)         \
    && ! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)
# undef _JITTER_RETURN_ADDRESS
#endif

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(tail-call-compiled/n4/retR, tail_mcall_mcompiled__n4__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for tail-call-compiled/n4/retR, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction tail-call-compiled/n5/retR */
  JITTER_INSTRUCTION_PROLOG_(tail-call-compiled/n5/retR, tail_mcall_mcompiled__n5__retR, cold)
  { /* This block begins with definitions for tail-call-compiled/n5/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       213
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         tail-call-compiled/n5/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "tail-call-compiled"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "tail-call-compiled/n5/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME tail_mcall_mcompiled__n5__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is a non-replacement and a caller.
       Its 1-th argument, a literal, is the return address where to jump
       back after the procedure returns.  Branch-and-link
       functionality is enabled for this instruction. */
/* This instruction is relocatable: use more efficient branches
   which can generate defects. */
#   undef JITTER_BRANCH_AND_LINK
#   define JITTER_BRANCH_AND_LINK      _JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   define JITTER_BRANCH_AND_LINK_WITH _JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK
#   define JITTER_BRANCH_FAST_AND_LINK _JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1

    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 5L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1


#if defined(JITTER_DISPATCH_NO_THREADING)             \
    && (! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)  \
        || /* is this a replacement? */ 0)
  /* We use the implicit argument at the end of the calling.
     instruction to discover the procedure return address. */
  const void * const _jitter_return_pointer
    __attribute__ ((unused)) = JITTER_ARGP1;
  /* And make it accessible to the user (who will usually call 
     JITTER_BRANCH_AND_LINK) thru a nice macro. */
# define _JITTER_RETURN_ADDRESS _jitter_return_pointer
#endif

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of tail-call-compiled/n5/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "tail-call-compiled/n5/retR"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for tail-call-compiled/n5/retR . */
  {
/* User-specified code, user code block part: beginning. */

    const jitter_uint in_arity = JITTER_ARGN0;
    jitterlisp_object callee = JITTER_AT_DEPTH_MAINSTACK(in_arity);
    struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(callee);

    /* Here we can assume that * c is a compiled closure without checking. */
    struct jitterlisp_compiled_closure *cc = & c->compiled;

    /* Take the current return address from the return stack: I want to keep
       returning there.  Differently from the case of non-tail calls I don't
       push anything on the return stack: the callee prolog will overwrite
       the current top with a copy of itself, which is fine. */
    jitterlispvm_program_point current_link
      = (jitterlispvm_program_point) JITTER_TOP_RETURNSTACK();

    /* Branch-and-relink to the native code, whose first instruction
       will be a prolog. */
    JITTER_BRANCH_AND_LINK_WITH(cc->first_program_point, current_link);
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for tail-call-compiled/n5/retR . */

  //fprintf (stderr, "..Executed instruction %s\n", "tail-call-compiled/n5/retR");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the tail-call-compiled/n5/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#if    defined(JITTER_DISPATCH_NO_THREADING)         \
    && ! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)
# undef _JITTER_RETURN_ADDRESS
#endif

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(tail-call-compiled/n5/retR, tail_mcall_mcompiled__n5__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for tail-call-compiled/n5/retR, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction tail-call-compiled/n6/retR */
  JITTER_INSTRUCTION_PROLOG_(tail-call-compiled/n6/retR, tail_mcall_mcompiled__n6__retR, cold)
  { /* This block begins with definitions for tail-call-compiled/n6/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       214
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         tail-call-compiled/n6/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "tail-call-compiled"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "tail-call-compiled/n6/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME tail_mcall_mcompiled__n6__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is a non-replacement and a caller.
       Its 1-th argument, a literal, is the return address where to jump
       back after the procedure returns.  Branch-and-link
       functionality is enabled for this instruction. */
/* This instruction is relocatable: use more efficient branches
   which can generate defects. */
#   undef JITTER_BRANCH_AND_LINK
#   define JITTER_BRANCH_AND_LINK      _JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   define JITTER_BRANCH_AND_LINK_WITH _JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK
#   define JITTER_BRANCH_FAST_AND_LINK _JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1

    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 6L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1


#if defined(JITTER_DISPATCH_NO_THREADING)             \
    && (! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)  \
        || /* is this a replacement? */ 0)
  /* We use the implicit argument at the end of the calling.
     instruction to discover the procedure return address. */
  const void * const _jitter_return_pointer
    __attribute__ ((unused)) = JITTER_ARGP1;
  /* And make it accessible to the user (who will usually call 
     JITTER_BRANCH_AND_LINK) thru a nice macro. */
# define _JITTER_RETURN_ADDRESS _jitter_return_pointer
#endif

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of tail-call-compiled/n6/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "tail-call-compiled/n6/retR"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for tail-call-compiled/n6/retR . */
  {
/* User-specified code, user code block part: beginning. */

    const jitter_uint in_arity = JITTER_ARGN0;
    jitterlisp_object callee = JITTER_AT_DEPTH_MAINSTACK(in_arity);
    struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(callee);

    /* Here we can assume that * c is a compiled closure without checking. */
    struct jitterlisp_compiled_closure *cc = & c->compiled;

    /* Take the current return address from the return stack: I want to keep
       returning there.  Differently from the case of non-tail calls I don't
       push anything on the return stack: the callee prolog will overwrite
       the current top with a copy of itself, which is fine. */
    jitterlispvm_program_point current_link
      = (jitterlispvm_program_point) JITTER_TOP_RETURNSTACK();

    /* Branch-and-relink to the native code, whose first instruction
       will be a prolog. */
    JITTER_BRANCH_AND_LINK_WITH(cc->first_program_point, current_link);
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for tail-call-compiled/n6/retR . */

  //fprintf (stderr, "..Executed instruction %s\n", "tail-call-compiled/n6/retR");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the tail-call-compiled/n6/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#if    defined(JITTER_DISPATCH_NO_THREADING)         \
    && ! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)
# undef _JITTER_RETURN_ADDRESS
#endif

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(tail-call-compiled/n6/retR, tail_mcall_mcompiled__n6__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for tail-call-compiled/n6/retR, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction tail-call-compiled/n7/retR */
  JITTER_INSTRUCTION_PROLOG_(tail-call-compiled/n7/retR, tail_mcall_mcompiled__n7__retR, cold)
  { /* This block begins with definitions for tail-call-compiled/n7/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       215
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         tail-call-compiled/n7/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "tail-call-compiled"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "tail-call-compiled/n7/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME tail_mcall_mcompiled__n7__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is a non-replacement and a caller.
       Its 1-th argument, a literal, is the return address where to jump
       back after the procedure returns.  Branch-and-link
       functionality is enabled for this instruction. */
/* This instruction is relocatable: use more efficient branches
   which can generate defects. */
#   undef JITTER_BRANCH_AND_LINK
#   define JITTER_BRANCH_AND_LINK      _JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   define JITTER_BRANCH_AND_LINK_WITH _JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK
#   define JITTER_BRANCH_FAST_AND_LINK _JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1

    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 7L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1


#if defined(JITTER_DISPATCH_NO_THREADING)             \
    && (! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)  \
        || /* is this a replacement? */ 0)
  /* We use the implicit argument at the end of the calling.
     instruction to discover the procedure return address. */
  const void * const _jitter_return_pointer
    __attribute__ ((unused)) = JITTER_ARGP1;
  /* And make it accessible to the user (who will usually call 
     JITTER_BRANCH_AND_LINK) thru a nice macro. */
# define _JITTER_RETURN_ADDRESS _jitter_return_pointer
#endif

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of tail-call-compiled/n7/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "tail-call-compiled/n7/retR"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for tail-call-compiled/n7/retR . */
  {
/* User-specified code, user code block part: beginning. */

    const jitter_uint in_arity = JITTER_ARGN0;
    jitterlisp_object callee = JITTER_AT_DEPTH_MAINSTACK(in_arity);
    struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(callee);

    /* Here we can assume that * c is a compiled closure without checking. */
    struct jitterlisp_compiled_closure *cc = & c->compiled;

    /* Take the current return address from the return stack: I want to keep
       returning there.  Differently from the case of non-tail calls I don't
       push anything on the return stack: the callee prolog will overwrite
       the current top with a copy of itself, which is fine. */
    jitterlispvm_program_point current_link
      = (jitterlispvm_program_point) JITTER_TOP_RETURNSTACK();

    /* Branch-and-relink to the native code, whose first instruction
       will be a prolog. */
    JITTER_BRANCH_AND_LINK_WITH(cc->first_program_point, current_link);
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for tail-call-compiled/n7/retR . */

  //fprintf (stderr, "..Executed instruction %s\n", "tail-call-compiled/n7/retR");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the tail-call-compiled/n7/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#if    defined(JITTER_DISPATCH_NO_THREADING)         \
    && ! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)
# undef _JITTER_RETURN_ADDRESS
#endif

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(tail-call-compiled/n7/retR, tail_mcall_mcompiled__n7__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for tail-call-compiled/n7/retR, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction tail-call-compiled/n8/retR */
  JITTER_INSTRUCTION_PROLOG_(tail-call-compiled/n8/retR, tail_mcall_mcompiled__n8__retR, cold)
  { /* This block begins with definitions for tail-call-compiled/n8/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       216
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         tail-call-compiled/n8/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "tail-call-compiled"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "tail-call-compiled/n8/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME tail_mcall_mcompiled__n8__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is a non-replacement and a caller.
       Its 1-th argument, a literal, is the return address where to jump
       back after the procedure returns.  Branch-and-link
       functionality is enabled for this instruction. */
/* This instruction is relocatable: use more efficient branches
   which can generate defects. */
#   undef JITTER_BRANCH_AND_LINK
#   define JITTER_BRANCH_AND_LINK      _JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   define JITTER_BRANCH_AND_LINK_WITH _JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK
#   define JITTER_BRANCH_FAST_AND_LINK _JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1

    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 8L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1


#if defined(JITTER_DISPATCH_NO_THREADING)             \
    && (! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)  \
        || /* is this a replacement? */ 0)
  /* We use the implicit argument at the end of the calling.
     instruction to discover the procedure return address. */
  const void * const _jitter_return_pointer
    __attribute__ ((unused)) = JITTER_ARGP1;
  /* And make it accessible to the user (who will usually call 
     JITTER_BRANCH_AND_LINK) thru a nice macro. */
# define _JITTER_RETURN_ADDRESS _jitter_return_pointer
#endif

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of tail-call-compiled/n8/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "tail-call-compiled/n8/retR"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for tail-call-compiled/n8/retR . */
  {
/* User-specified code, user code block part: beginning. */

    const jitter_uint in_arity = JITTER_ARGN0;
    jitterlisp_object callee = JITTER_AT_DEPTH_MAINSTACK(in_arity);
    struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(callee);

    /* Here we can assume that * c is a compiled closure without checking. */
    struct jitterlisp_compiled_closure *cc = & c->compiled;

    /* Take the current return address from the return stack: I want to keep
       returning there.  Differently from the case of non-tail calls I don't
       push anything on the return stack: the callee prolog will overwrite
       the current top with a copy of itself, which is fine. */
    jitterlispvm_program_point current_link
      = (jitterlispvm_program_point) JITTER_TOP_RETURNSTACK();

    /* Branch-and-relink to the native code, whose first instruction
       will be a prolog. */
    JITTER_BRANCH_AND_LINK_WITH(cc->first_program_point, current_link);
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for tail-call-compiled/n8/retR . */

  //fprintf (stderr, "..Executed instruction %s\n", "tail-call-compiled/n8/retR");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the tail-call-compiled/n8/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#if    defined(JITTER_DISPATCH_NO_THREADING)         \
    && ! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)
# undef _JITTER_RETURN_ADDRESS
#endif

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(tail-call-compiled/n8/retR, tail_mcall_mcompiled__n8__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for tail-call-compiled/n8/retR, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction tail-call-compiled/n9/retR */
  JITTER_INSTRUCTION_PROLOG_(tail-call-compiled/n9/retR, tail_mcall_mcompiled__n9__retR, cold)
  { /* This block begins with definitions for tail-call-compiled/n9/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       217
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         tail-call-compiled/n9/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "tail-call-compiled"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "tail-call-compiled/n9/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME tail_mcall_mcompiled__n9__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is a non-replacement and a caller.
       Its 1-th argument, a literal, is the return address where to jump
       back after the procedure returns.  Branch-and-link
       functionality is enabled for this instruction. */
/* This instruction is relocatable: use more efficient branches
   which can generate defects. */
#   undef JITTER_BRANCH_AND_LINK
#   define JITTER_BRANCH_AND_LINK      _JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   define JITTER_BRANCH_AND_LINK_WITH _JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK
#   define JITTER_BRANCH_FAST_AND_LINK _JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1

    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 9L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1


#if defined(JITTER_DISPATCH_NO_THREADING)             \
    && (! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)  \
        || /* is this a replacement? */ 0)
  /* We use the implicit argument at the end of the calling.
     instruction to discover the procedure return address. */
  const void * const _jitter_return_pointer
    __attribute__ ((unused)) = JITTER_ARGP1;
  /* And make it accessible to the user (who will usually call 
     JITTER_BRANCH_AND_LINK) thru a nice macro. */
# define _JITTER_RETURN_ADDRESS _jitter_return_pointer
#endif

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of tail-call-compiled/n9/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "tail-call-compiled/n9/retR"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for tail-call-compiled/n9/retR . */
  {
/* User-specified code, user code block part: beginning. */

    const jitter_uint in_arity = JITTER_ARGN0;
    jitterlisp_object callee = JITTER_AT_DEPTH_MAINSTACK(in_arity);
    struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(callee);

    /* Here we can assume that * c is a compiled closure without checking. */
    struct jitterlisp_compiled_closure *cc = & c->compiled;

    /* Take the current return address from the return stack: I want to keep
       returning there.  Differently from the case of non-tail calls I don't
       push anything on the return stack: the callee prolog will overwrite
       the current top with a copy of itself, which is fine. */
    jitterlispvm_program_point current_link
      = (jitterlispvm_program_point) JITTER_TOP_RETURNSTACK();

    /* Branch-and-relink to the native code, whose first instruction
       will be a prolog. */
    JITTER_BRANCH_AND_LINK_WITH(cc->first_program_point, current_link);
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for tail-call-compiled/n9/retR . */

  //fprintf (stderr, "..Executed instruction %s\n", "tail-call-compiled/n9/retR");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the tail-call-compiled/n9/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#if    defined(JITTER_DISPATCH_NO_THREADING)         \
    && ! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)
# undef _JITTER_RETURN_ADDRESS
#endif

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(tail-call-compiled/n9/retR, tail_mcall_mcompiled__n9__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for tail-call-compiled/n9/retR, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction tail-call-compiled/n10/retR */
  JITTER_INSTRUCTION_PROLOG_(tail-call-compiled/n10/retR, tail_mcall_mcompiled__n10__retR, cold)
  { /* This block begins with definitions for tail-call-compiled/n10/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       218
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         tail-call-compiled/n10/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "tail-call-compiled"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "tail-call-compiled/n10/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME tail_mcall_mcompiled__n10__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is a non-replacement and a caller.
       Its 1-th argument, a literal, is the return address where to jump
       back after the procedure returns.  Branch-and-link
       functionality is enabled for this instruction. */
/* This instruction is relocatable: use more efficient branches
   which can generate defects. */
#   undef JITTER_BRANCH_AND_LINK
#   define JITTER_BRANCH_AND_LINK      _JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   define JITTER_BRANCH_AND_LINK_WITH _JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK
#   define JITTER_BRANCH_FAST_AND_LINK _JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1

    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 10L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1


#if defined(JITTER_DISPATCH_NO_THREADING)             \
    && (! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)  \
        || /* is this a replacement? */ 0)
  /* We use the implicit argument at the end of the calling.
     instruction to discover the procedure return address. */
  const void * const _jitter_return_pointer
    __attribute__ ((unused)) = JITTER_ARGP1;
  /* And make it accessible to the user (who will usually call 
     JITTER_BRANCH_AND_LINK) thru a nice macro. */
# define _JITTER_RETURN_ADDRESS _jitter_return_pointer
#endif

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of tail-call-compiled/n10/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "tail-call-compiled/n10/retR"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for tail-call-compiled/n10/retR . */
  {
/* User-specified code, user code block part: beginning. */

    const jitter_uint in_arity = JITTER_ARGN0;
    jitterlisp_object callee = JITTER_AT_DEPTH_MAINSTACK(in_arity);
    struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(callee);

    /* Here we can assume that * c is a compiled closure without checking. */
    struct jitterlisp_compiled_closure *cc = & c->compiled;

    /* Take the current return address from the return stack: I want to keep
       returning there.  Differently from the case of non-tail calls I don't
       push anything on the return stack: the callee prolog will overwrite
       the current top with a copy of itself, which is fine. */
    jitterlispvm_program_point current_link
      = (jitterlispvm_program_point) JITTER_TOP_RETURNSTACK();

    /* Branch-and-relink to the native code, whose first instruction
       will be a prolog. */
    JITTER_BRANCH_AND_LINK_WITH(cc->first_program_point, current_link);
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for tail-call-compiled/n10/retR . */

  //fprintf (stderr, "..Executed instruction %s\n", "tail-call-compiled/n10/retR");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the tail-call-compiled/n10/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#if    defined(JITTER_DISPATCH_NO_THREADING)         \
    && ! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)
# undef _JITTER_RETURN_ADDRESS
#endif

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(tail-call-compiled/n10/retR, tail_mcall_mcompiled__n10__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for tail-call-compiled/n10/retR, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction tail-call-compiled/nR/retR */
  JITTER_INSTRUCTION_PROLOG_(tail-call-compiled/nR/retR, tail_mcall_mcompiled__nR__retR, cold)
  { /* This block begins with definitions for tail-call-compiled/nR/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       219
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         tail-call-compiled/nR/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "tail-call-compiled"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "tail-call-compiled/nR/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME tail_mcall_mcompiled__nR__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is a non-replacement and a caller.
       Its 1-th argument, a literal, is the return address where to jump
       back after the procedure returns.  Branch-and-link
       functionality is enabled for this instruction. */
/* This instruction is relocatable: use more efficient branches
   which can generate defects. */
#   undef JITTER_BRANCH_AND_LINK
#   define JITTER_BRANCH_AND_LINK      _JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   define JITTER_BRANCH_AND_LINK_WITH _JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK
#   define JITTER_BRANCH_FAST_AND_LINK _JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 2

    /* The 0th argument is a residual literal. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1


#if defined(JITTER_DISPATCH_NO_THREADING)             \
    && (! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)  \
        || /* is this a replacement? */ 0)
  /* We use the implicit argument at the end of the calling.
     instruction to discover the procedure return address. */
  const void * const _jitter_return_pointer
    __attribute__ ((unused)) = JITTER_ARGP1;
  /* And make it accessible to the user (who will usually call 
     JITTER_BRANCH_AND_LINK) thru a nice macro. */
# define _JITTER_RETURN_ADDRESS _jitter_return_pointer
#endif

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of tail-call-compiled/nR/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "tail-call-compiled/nR/retR"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for tail-call-compiled/nR/retR . */
  {
/* User-specified code, user code block part: beginning. */

    const jitter_uint in_arity = JITTER_ARGN0;
    jitterlisp_object callee = JITTER_AT_DEPTH_MAINSTACK(in_arity);
    struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(callee);

    /* Here we can assume that * c is a compiled closure without checking. */
    struct jitterlisp_compiled_closure *cc = & c->compiled;

    /* Take the current return address from the return stack: I want to keep
       returning there.  Differently from the case of non-tail calls I don't
       push anything on the return stack: the callee prolog will overwrite
       the current top with a copy of itself, which is fine. */
    jitterlispvm_program_point current_link
      = (jitterlispvm_program_point) JITTER_TOP_RETURNSTACK();

    /* Branch-and-relink to the native code, whose first instruction
       will be a prolog. */
    JITTER_BRANCH_AND_LINK_WITH(cc->first_program_point, current_link);
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for tail-call-compiled/nR/retR . */

  //fprintf (stderr, "..Executed instruction %s\n", "tail-call-compiled/nR/retR");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the tail-call-compiled/nR/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#if    defined(JITTER_DISPATCH_NO_THREADING)         \
    && ! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)
# undef _JITTER_RETURN_ADDRESS
#endif

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(tail-call-compiled/nR/retR, tail_mcall_mcompiled__nR__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for tail-call-compiled/nR/retR, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction unreachable */
  JITTER_INSTRUCTION_PROLOG_(unreachable, unreachable, cold)
  { /* This block begins with definitions for unreachable . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       220
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         unreachable
#   define JITTER_INSTRUCTION_NAME_AS_STRING "unreachable"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "unreachable"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME unreachable

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is not a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0


#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of unreachable ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  yes. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
  //fprintf (stderr, "Executing instruction %s..\n", "unreachable"); fflush (stderr);
#undef JITTER_THIS_IS_A_REPLACEMENT
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#define JITTER_THIS_IS_NOT_A_REPLACEMENT 1

    /* User code for unreachable . */
  {
/* User-specified code, user code block part: beginning. */

/* User-specified code, user code block part: end */

  }
    /* End of the user code for unreachable . */

  //fprintf (stderr, "..Executed instruction %s\n", "unreachable");
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
    /* Undefine the unreachable argument macros so they can't be used
       by mistake in the instruction body coming next. */

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(unreachable, unreachable, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for unreachable, which started with its
       definitions. */
  }

  /* Ordinary specialised instruction !REPLACEMENT-branch/fR/retR (replacement) */
  /* Omit this specialised instruction altogether unless
     replacements are in fact supported in this
     configuration. */
#if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
  JITTER_INSTRUCTION_PROLOG_(!REPLACEMENT-branch/fR/retR, _eREPLACEMENT_mbranch__fR__retR, cold)
  { /* This block begins with definitions for !REPLACEMENT-branch/fR/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       221
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         !REPLACEMENT-branch/fR/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "branch"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "!REPLACEMENT-branch/fR/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _eREPLACEMENT_mbranch__fR__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST JITTER_BRANCH
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 2

  /* Define argument-access macros for !REPLACEMENT-branch/fR/retR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
    /* The 0th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* When jumping to the non-relocatable part it is important not
   to use a fallback version of JITTER_COMPUTED_GOTO, in order to
   prevent GCC from tail-merging. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
    /* Jump to non-relocatable code. */
    JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);

    /* Here the residual arity is given as zero: it's too late to
       skip residuals, since we've already jumped and this code is
       unreachable.  The instruction pointer, if any, is advanced
       in the non-relocatable code. */
    JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-branch/fR/retR, _eREPLACEMENT_mbranch__fR__retR, 0)

    /* Relocated code will jump to this label in non-relocated code. */
  JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
    JITTER_COMMENT_IN_ASM_("!REPLACEMENT-branch/fR/retR non-relocatable code");
#endif // #ifdef JITTER_REPLICATE
#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of !REPLACEMENT-branch/fR/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  no. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
//#if 0
  //fprintf (stderr, "Executing instruction %s..\n", "!REPLACEMENT-branch/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing replacement instruction %s..\n", "!REPLACEMENT-branch/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing non-relocatable instruction %s with JITTER_SPECIALIZED_INSTRUCTION_WORD_NO=%i..\n", "!REPLACEMENT-branch/fR/retR", (int) JITTER_SPECIALIZED_INSTRUCTION_WORD_NO); fflush (stderr);
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#undef JITTER_THIS_IS_A_REPLACEMENT
#define JITTER_THIS_IS_A_REPLACEMENT 1

    /* User code for !REPLACEMENT-branch/fR/retR . */
  {
/* User-specified code, user code block part: beginning. */

    JITTER_BRANCH_FAST(JITTER_ARGF0);
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for !REPLACEMENT-branch/fR/retR . */

  //fprintf (stderr, "..Executed replacement instruction %s\n", "!REPLACEMENT-branch/fR/retR");
  //fprintf (stderr, "..Executed instruction %s\n", "!REPLACEMENT-branch/fR/retR");
//#endif // #if 0
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
#ifdef JITTER_REPLICATE
  {
    /* Advance the instruction pointer, if any, to skip every
       residual but the last; branch back to replicated
       code. */
    const void *_jitter_back_to_replicated_code_pointer =
      JITTER_ARGP1;
    JITTER_SKIP_RESIDUALS_;
    goto * _jitter_back_to_replicated_code_pointer;
  }
#endif // #ifdef JITTER_REPLICATE

    /* Undefine the !REPLACEMENT-branch/fR/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#ifndef JITTER_REPLICATE
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-branch/fR/retR, _eREPLACEMENT_mbranch__fR__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#endif // #ifndef JITTER_REPLICATE
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for !REPLACEMENT-branch/fR/retR, which started with its
       definitions. */
  }
#endif // #if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
/*  End of !REPLACEMENT-branch/fR/retR , a replacement specialised instruction */

  /* Ordinary specialised instruction !REPLACEMENT-branch-if-false/fR/retR (replacement) */
  /* Omit this specialised instruction altogether unless
     replacements are in fact supported in this
     configuration. */
#if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
  JITTER_INSTRUCTION_PROLOG_(!REPLACEMENT-branch-if-false/fR/retR, _eREPLACEMENT_mbranch_mif_mfalse__fR__retR, cold)
  { /* This block begins with definitions for !REPLACEMENT-branch-if-false/fR/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       222
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         !REPLACEMENT-branch-if-false/fR/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "branch-if-false"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "!REPLACEMENT-branch-if-false/fR/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _eREPLACEMENT_mbranch_mif_mfalse__fR__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST JITTER_BRANCH
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 2

  /* Define argument-access macros for !REPLACEMENT-branch-if-false/fR/retR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
    /* The 0th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* When jumping to the non-relocatable part it is important not
   to use a fallback version of JITTER_COMPUTED_GOTO, in order to
   prevent GCC from tail-merging. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
    /* Jump to non-relocatable code. */
    JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);

    /* Here the residual arity is given as zero: it's too late to
       skip residuals, since we've already jumped and this code is
       unreachable.  The instruction pointer, if any, is advanced
       in the non-relocatable code. */
    JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-branch-if-false/fR/retR, _eREPLACEMENT_mbranch_mif_mfalse__fR__retR, 0)

    /* Relocated code will jump to this label in non-relocated code. */
  JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
    JITTER_COMMENT_IN_ASM_("!REPLACEMENT-branch-if-false/fR/retR non-relocatable code");
#endif // #ifdef JITTER_REPLICATE
#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of !REPLACEMENT-branch-if-false/fR/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  no. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
//#if 0
  //fprintf (stderr, "Executing instruction %s..\n", "!REPLACEMENT-branch-if-false/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing replacement instruction %s..\n", "!REPLACEMENT-branch-if-false/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing non-relocatable instruction %s with JITTER_SPECIALIZED_INSTRUCTION_WORD_NO=%i..\n", "!REPLACEMENT-branch-if-false/fR/retR", (int) JITTER_SPECIALIZED_INSTRUCTION_WORD_NO); fflush (stderr);
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#undef JITTER_THIS_IS_A_REPLACEMENT
#define JITTER_THIS_IS_A_REPLACEMENT 1

    /* User code for !REPLACEMENT-branch-if-false/fR/retR . */
  {
/* User-specified code, user code block part: beginning. */

    jitterlisp_object top = JITTER_TOP_MAINSTACK();
    JITTER_DROP_MAINSTACK();
    JITTER_BRANCH_FAST_IF_EQUAL(top, JITTERLISP_FALSE, JITTER_ARGF0);
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for !REPLACEMENT-branch-if-false/fR/retR . */

  //fprintf (stderr, "..Executed replacement instruction %s\n", "!REPLACEMENT-branch-if-false/fR/retR");
  //fprintf (stderr, "..Executed instruction %s\n", "!REPLACEMENT-branch-if-false/fR/retR");
//#endif // #if 0
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
#ifdef JITTER_REPLICATE
  {
    /* Advance the instruction pointer, if any, to skip every
       residual but the last; branch back to replicated
       code. */
    const void *_jitter_back_to_replicated_code_pointer =
      JITTER_ARGP1;
    JITTER_SKIP_RESIDUALS_;
    goto * _jitter_back_to_replicated_code_pointer;
  }
#endif // #ifdef JITTER_REPLICATE

    /* Undefine the !REPLACEMENT-branch-if-false/fR/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#ifndef JITTER_REPLICATE
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-branch-if-false/fR/retR, _eREPLACEMENT_mbranch_mif_mfalse__fR__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#endif // #ifndef JITTER_REPLICATE
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for !REPLACEMENT-branch-if-false/fR/retR, which started with its
       definitions. */
  }
#endif // #if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
/*  End of !REPLACEMENT-branch-if-false/fR/retR , a replacement specialised instruction */

  /* Ordinary specialised instruction !REPLACEMENT-branch-if-non-positive/fR/fR/retR (replacement) */
  /* Omit this specialised instruction altogether unless
     replacements are in fact supported in this
     configuration. */
#if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
  JITTER_INSTRUCTION_PROLOG_(!REPLACEMENT-branch-if-non-positive/fR/fR/retR, _eREPLACEMENT_mbranch_mif_mnon_mpositive__fR__fR__retR, cold)
  { /* This block begins with definitions for !REPLACEMENT-branch-if-non-positive/fR/fR/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       223
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         !REPLACEMENT-branch-if-non-positive/fR/fR/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "branch-if-non-positive"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "!REPLACEMENT-branch-if-non-positive/fR/fR/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _eREPLACEMENT_mbranch_mif_mnon_mpositive__fR__fR__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is non-relocatable.
       Its 2-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST JITTER_BRANCH
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
    /* This specialized instruction is non-relocatable.
       Its 2-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 3

  /* Define argument-access macros for !REPLACEMENT-branch-if-non-positive/fR/fR/retR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

    /* The 2th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG2  JITTER_RESIDUAL_ARGUMENT_2
    JITTER_MARK_RESIDUAL_2_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[2])
#else
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[3])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN2 (JITTER_ARG2.fixnum)
#   define JITTER_ARGU2 (JITTER_ARG2.ufixnum)
#   define JITTER_ARGP2 (JITTER_ARG2.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
    /* The 0th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

    /* The 2th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG2  JITTER_RESIDUAL_ARGUMENT_2
    JITTER_MARK_RESIDUAL_2_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[2])
#else
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[3])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN2 (JITTER_ARG2.fixnum)
#   define JITTER_ARGU2 (JITTER_ARG2.ufixnum)
#   define JITTER_ARGP2 (JITTER_ARG2.pointer)
#   define JITTER_ARGF2 JITTER_ARGP2

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* When jumping to the non-relocatable part it is important not
   to use a fallback version of JITTER_COMPUTED_GOTO, in order to
   prevent GCC from tail-merging. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
    /* Jump to non-relocatable code. */
    JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);

    /* Here the residual arity is given as zero: it's too late to
       skip residuals, since we've already jumped and this code is
       unreachable.  The instruction pointer, if any, is advanced
       in the non-relocatable code. */
    JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-branch-if-non-positive/fR/fR/retR, _eREPLACEMENT_mbranch_mif_mnon_mpositive__fR__fR__retR, 0)

    /* Relocated code will jump to this label in non-relocated code. */
  JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
    JITTER_COMMENT_IN_ASM_("!REPLACEMENT-branch-if-non-positive/fR/fR/retR non-relocatable code");
#endif // #ifdef JITTER_REPLICATE
#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of !REPLACEMENT-branch-if-non-positive/fR/fR/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  no. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
//#if 0
  //fprintf (stderr, "Executing instruction %s..\n", "!REPLACEMENT-branch-if-non-positive/fR/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing replacement instruction %s..\n", "!REPLACEMENT-branch-if-non-positive/fR/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing non-relocatable instruction %s with JITTER_SPECIALIZED_INSTRUCTION_WORD_NO=%i..\n", "!REPLACEMENT-branch-if-non-positive/fR/fR/retR", (int) JITTER_SPECIALIZED_INSTRUCTION_WORD_NO); fflush (stderr);
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#undef JITTER_THIS_IS_A_REPLACEMENT
#define JITTER_THIS_IS_A_REPLACEMENT 1

    /* User code for !REPLACEMENT-branch-if-non-positive/fR/fR/retR . */
  {
/* User-specified code, user code block part: beginning. */

    JITTERLISPVM_CHECK_TYPES_1(FIXNUM, JITTER_ARGF1);
    jitterlisp_object top = JITTER_TOP_MAINSTACK();
    JITTER_DROP_MAINSTACK();
    JITTER_BRANCH_FAST_IF_NONPOSITIVE(top, JITTER_ARGF0);
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for !REPLACEMENT-branch-if-non-positive/fR/fR/retR . */

  //fprintf (stderr, "..Executed replacement instruction %s\n", "!REPLACEMENT-branch-if-non-positive/fR/fR/retR");
  //fprintf (stderr, "..Executed instruction %s\n", "!REPLACEMENT-branch-if-non-positive/fR/fR/retR");
//#endif // #if 0
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
#ifdef JITTER_REPLICATE
  {
    /* Advance the instruction pointer, if any, to skip every
       residual but the last; branch back to replicated
       code. */
    const void *_jitter_back_to_replicated_code_pointer =
      JITTER_ARGP2;
    JITTER_SKIP_RESIDUALS_;
    goto * _jitter_back_to_replicated_code_pointer;
  }
#endif // #ifdef JITTER_REPLICATE

    /* Undefine the !REPLACEMENT-branch-if-non-positive/fR/fR/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1
#   undef JITTER_SLOW_REGISTER_OFFSET2
#   undef JITTER_ARG2
#   undef JITTER_ARGN2
#   undef JITTER_ARGU2
#   undef JITTER_ARGP2
#   undef JITTER_ARGF2

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#ifndef JITTER_REPLICATE
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-branch-if-non-positive/fR/fR/retR, _eREPLACEMENT_mbranch_mif_mnon_mpositive__fR__fR__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#endif // #ifndef JITTER_REPLICATE
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for !REPLACEMENT-branch-if-non-positive/fR/fR/retR, which started with its
       definitions. */
  }
#endif // #if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
/*  End of !REPLACEMENT-branch-if-non-positive/fR/fR/retR , a replacement specialised instruction */

  /* Ordinary specialised instruction !REPLACEMENT-branch-if-not-less/fR/fR/retR (replacement) */
  /* Omit this specialised instruction altogether unless
     replacements are in fact supported in this
     configuration. */
#if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
  JITTER_INSTRUCTION_PROLOG_(!REPLACEMENT-branch-if-not-less/fR/fR/retR, _eREPLACEMENT_mbranch_mif_mnot_mless__fR__fR__retR, cold)
  { /* This block begins with definitions for !REPLACEMENT-branch-if-not-less/fR/fR/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       224
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         !REPLACEMENT-branch-if-not-less/fR/fR/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "branch-if-not-less"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "!REPLACEMENT-branch-if-not-less/fR/fR/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _eREPLACEMENT_mbranch_mif_mnot_mless__fR__fR__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is non-relocatable.
       Its 2-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST JITTER_BRANCH
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
    /* This specialized instruction is non-relocatable.
       Its 2-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 3

  /* Define argument-access macros for !REPLACEMENT-branch-if-not-less/fR/fR/retR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

    /* The 2th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG2  JITTER_RESIDUAL_ARGUMENT_2
    JITTER_MARK_RESIDUAL_2_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[2])
#else
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[3])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN2 (JITTER_ARG2.fixnum)
#   define JITTER_ARGU2 (JITTER_ARG2.ufixnum)
#   define JITTER_ARGP2 (JITTER_ARG2.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
    /* The 0th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

    /* The 2th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG2  JITTER_RESIDUAL_ARGUMENT_2
    JITTER_MARK_RESIDUAL_2_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[2])
#else
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[3])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN2 (JITTER_ARG2.fixnum)
#   define JITTER_ARGU2 (JITTER_ARG2.ufixnum)
#   define JITTER_ARGP2 (JITTER_ARG2.pointer)
#   define JITTER_ARGF2 JITTER_ARGP2

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* When jumping to the non-relocatable part it is important not
   to use a fallback version of JITTER_COMPUTED_GOTO, in order to
   prevent GCC from tail-merging. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
    /* Jump to non-relocatable code. */
    JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);

    /* Here the residual arity is given as zero: it's too late to
       skip residuals, since we've already jumped and this code is
       unreachable.  The instruction pointer, if any, is advanced
       in the non-relocatable code. */
    JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-branch-if-not-less/fR/fR/retR, _eREPLACEMENT_mbranch_mif_mnot_mless__fR__fR__retR, 0)

    /* Relocated code will jump to this label in non-relocated code. */
  JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
    JITTER_COMMENT_IN_ASM_("!REPLACEMENT-branch-if-not-less/fR/fR/retR non-relocatable code");
#endif // #ifdef JITTER_REPLICATE
#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of !REPLACEMENT-branch-if-not-less/fR/fR/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  no. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
//#if 0
  //fprintf (stderr, "Executing instruction %s..\n", "!REPLACEMENT-branch-if-not-less/fR/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing replacement instruction %s..\n", "!REPLACEMENT-branch-if-not-less/fR/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing non-relocatable instruction %s with JITTER_SPECIALIZED_INSTRUCTION_WORD_NO=%i..\n", "!REPLACEMENT-branch-if-not-less/fR/fR/retR", (int) JITTER_SPECIALIZED_INSTRUCTION_WORD_NO); fflush (stderr);
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#undef JITTER_THIS_IS_A_REPLACEMENT
#define JITTER_THIS_IS_A_REPLACEMENT 1

    /* User code for !REPLACEMENT-branch-if-not-less/fR/fR/retR . */
  {
/* User-specified code, user code block part: beginning. */

    JITTERLISPVM_CHECK_TYPES_2(FIXNUM, FIXNUM, JITTER_ARGF1);
    jitterlisp_object undertop = JITTER_UNDER_TOP_MAINSTACK();
    jitterlisp_object top = JITTER_TOP_MAINSTACK();
    JITTER_NIP_MAINSTACK();
    JITTER_DROP_MAINSTACK();
    JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED(undertop, top, JITTER_ARGF0);
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for !REPLACEMENT-branch-if-not-less/fR/fR/retR . */

  //fprintf (stderr, "..Executed replacement instruction %s\n", "!REPLACEMENT-branch-if-not-less/fR/fR/retR");
  //fprintf (stderr, "..Executed instruction %s\n", "!REPLACEMENT-branch-if-not-less/fR/fR/retR");
//#endif // #if 0
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
#ifdef JITTER_REPLICATE
  {
    /* Advance the instruction pointer, if any, to skip every
       residual but the last; branch back to replicated
       code. */
    const void *_jitter_back_to_replicated_code_pointer =
      JITTER_ARGP2;
    JITTER_SKIP_RESIDUALS_;
    goto * _jitter_back_to_replicated_code_pointer;
  }
#endif // #ifdef JITTER_REPLICATE

    /* Undefine the !REPLACEMENT-branch-if-not-less/fR/fR/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1
#   undef JITTER_SLOW_REGISTER_OFFSET2
#   undef JITTER_ARG2
#   undef JITTER_ARGN2
#   undef JITTER_ARGU2
#   undef JITTER_ARGP2
#   undef JITTER_ARGF2

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#ifndef JITTER_REPLICATE
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-branch-if-not-less/fR/fR/retR, _eREPLACEMENT_mbranch_mif_mnot_mless__fR__fR__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#endif // #ifndef JITTER_REPLICATE
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for !REPLACEMENT-branch-if-not-less/fR/fR/retR, which started with its
       definitions. */
  }
#endif // #if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
/*  End of !REPLACEMENT-branch-if-not-less/fR/fR/retR , a replacement specialised instruction */

  /* Ordinary specialised instruction !REPLACEMENT-branch-if-not-null/fR/retR (replacement) */
  /* Omit this specialised instruction altogether unless
     replacements are in fact supported in this
     configuration. */
#if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
  JITTER_INSTRUCTION_PROLOG_(!REPLACEMENT-branch-if-not-null/fR/retR, _eREPLACEMENT_mbranch_mif_mnot_mnull__fR__retR, cold)
  { /* This block begins with definitions for !REPLACEMENT-branch-if-not-null/fR/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       225
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         !REPLACEMENT-branch-if-not-null/fR/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "branch-if-not-null"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "!REPLACEMENT-branch-if-not-null/fR/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _eREPLACEMENT_mbranch_mif_mnot_mnull__fR__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST JITTER_BRANCH
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 2

  /* Define argument-access macros for !REPLACEMENT-branch-if-not-null/fR/retR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
    /* The 0th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* When jumping to the non-relocatable part it is important not
   to use a fallback version of JITTER_COMPUTED_GOTO, in order to
   prevent GCC from tail-merging. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
    /* Jump to non-relocatable code. */
    JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);

    /* Here the residual arity is given as zero: it's too late to
       skip residuals, since we've already jumped and this code is
       unreachable.  The instruction pointer, if any, is advanced
       in the non-relocatable code. */
    JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-branch-if-not-null/fR/retR, _eREPLACEMENT_mbranch_mif_mnot_mnull__fR__retR, 0)

    /* Relocated code will jump to this label in non-relocated code. */
  JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
    JITTER_COMMENT_IN_ASM_("!REPLACEMENT-branch-if-not-null/fR/retR non-relocatable code");
#endif // #ifdef JITTER_REPLICATE
#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of !REPLACEMENT-branch-if-not-null/fR/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  no. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
//#if 0
  //fprintf (stderr, "Executing instruction %s..\n", "!REPLACEMENT-branch-if-not-null/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing replacement instruction %s..\n", "!REPLACEMENT-branch-if-not-null/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing non-relocatable instruction %s with JITTER_SPECIALIZED_INSTRUCTION_WORD_NO=%i..\n", "!REPLACEMENT-branch-if-not-null/fR/retR", (int) JITTER_SPECIALIZED_INSTRUCTION_WORD_NO); fflush (stderr);
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#undef JITTER_THIS_IS_A_REPLACEMENT
#define JITTER_THIS_IS_A_REPLACEMENT 1

    /* User code for !REPLACEMENT-branch-if-not-null/fR/retR . */
  {
/* User-specified code, user code block part: beginning. */

    jitterlisp_object top = JITTER_TOP_MAINSTACK();
    JITTER_DROP_MAINSTACK();
    JITTER_BRANCH_FAST_IF_NOTEQUAL(top, JITTERLISP_EMPTY_LIST, JITTER_ARGF0);
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for !REPLACEMENT-branch-if-not-null/fR/retR . */

  //fprintf (stderr, "..Executed replacement instruction %s\n", "!REPLACEMENT-branch-if-not-null/fR/retR");
  //fprintf (stderr, "..Executed instruction %s\n", "!REPLACEMENT-branch-if-not-null/fR/retR");
//#endif // #if 0
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
#ifdef JITTER_REPLICATE
  {
    /* Advance the instruction pointer, if any, to skip every
       residual but the last; branch back to replicated
       code. */
    const void *_jitter_back_to_replicated_code_pointer =
      JITTER_ARGP1;
    JITTER_SKIP_RESIDUALS_;
    goto * _jitter_back_to_replicated_code_pointer;
  }
#endif // #ifdef JITTER_REPLICATE

    /* Undefine the !REPLACEMENT-branch-if-not-null/fR/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#ifndef JITTER_REPLICATE
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-branch-if-not-null/fR/retR, _eREPLACEMENT_mbranch_mif_mnot_mnull__fR__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#endif // #ifndef JITTER_REPLICATE
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for !REPLACEMENT-branch-if-not-null/fR/retR, which started with its
       definitions. */
  }
#endif // #if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
/*  End of !REPLACEMENT-branch-if-not-null/fR/retR , a replacement specialised instruction */

  /* Ordinary specialised instruction !REPLACEMENT-branch-if-null/fR/retR (replacement) */
  /* Omit this specialised instruction altogether unless
     replacements are in fact supported in this
     configuration. */
#if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
  JITTER_INSTRUCTION_PROLOG_(!REPLACEMENT-branch-if-null/fR/retR, _eREPLACEMENT_mbranch_mif_mnull__fR__retR, cold)
  { /* This block begins with definitions for !REPLACEMENT-branch-if-null/fR/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       226
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         !REPLACEMENT-branch-if-null/fR/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "branch-if-null"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "!REPLACEMENT-branch-if-null/fR/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _eREPLACEMENT_mbranch_mif_mnull__fR__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST JITTER_BRANCH
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 2

  /* Define argument-access macros for !REPLACEMENT-branch-if-null/fR/retR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
    /* The 0th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* When jumping to the non-relocatable part it is important not
   to use a fallback version of JITTER_COMPUTED_GOTO, in order to
   prevent GCC from tail-merging. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
    /* Jump to non-relocatable code. */
    JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);

    /* Here the residual arity is given as zero: it's too late to
       skip residuals, since we've already jumped and this code is
       unreachable.  The instruction pointer, if any, is advanced
       in the non-relocatable code. */
    JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-branch-if-null/fR/retR, _eREPLACEMENT_mbranch_mif_mnull__fR__retR, 0)

    /* Relocated code will jump to this label in non-relocated code. */
  JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
    JITTER_COMMENT_IN_ASM_("!REPLACEMENT-branch-if-null/fR/retR non-relocatable code");
#endif // #ifdef JITTER_REPLICATE
#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of !REPLACEMENT-branch-if-null/fR/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  no. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
//#if 0
  //fprintf (stderr, "Executing instruction %s..\n", "!REPLACEMENT-branch-if-null/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing replacement instruction %s..\n", "!REPLACEMENT-branch-if-null/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing non-relocatable instruction %s with JITTER_SPECIALIZED_INSTRUCTION_WORD_NO=%i..\n", "!REPLACEMENT-branch-if-null/fR/retR", (int) JITTER_SPECIALIZED_INSTRUCTION_WORD_NO); fflush (stderr);
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#undef JITTER_THIS_IS_A_REPLACEMENT
#define JITTER_THIS_IS_A_REPLACEMENT 1

    /* User code for !REPLACEMENT-branch-if-null/fR/retR . */
  {
/* User-specified code, user code block part: beginning. */

    jitterlisp_object top = JITTER_TOP_MAINSTACK();
    JITTER_DROP_MAINSTACK();
    JITTER_BRANCH_FAST_IF_EQUAL(top, JITTERLISP_EMPTY_LIST, JITTER_ARGF0);
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for !REPLACEMENT-branch-if-null/fR/retR . */

  //fprintf (stderr, "..Executed replacement instruction %s\n", "!REPLACEMENT-branch-if-null/fR/retR");
  //fprintf (stderr, "..Executed instruction %s\n", "!REPLACEMENT-branch-if-null/fR/retR");
//#endif // #if 0
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
#ifdef JITTER_REPLICATE
  {
    /* Advance the instruction pointer, if any, to skip every
       residual but the last; branch back to replicated
       code. */
    const void *_jitter_back_to_replicated_code_pointer =
      JITTER_ARGP1;
    JITTER_SKIP_RESIDUALS_;
    goto * _jitter_back_to_replicated_code_pointer;
  }
#endif // #ifdef JITTER_REPLICATE

    /* Undefine the !REPLACEMENT-branch-if-null/fR/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#ifndef JITTER_REPLICATE
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-branch-if-null/fR/retR, _eREPLACEMENT_mbranch_mif_mnull__fR__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#endif // #ifndef JITTER_REPLICATE
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for !REPLACEMENT-branch-if-null/fR/retR, which started with its
       definitions. */
  }
#endif // #if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
/*  End of !REPLACEMENT-branch-if-null/fR/retR , a replacement specialised instruction */

  /* Ordinary specialised instruction !REPLACEMENT-branch-if-positive/fR/fR/retR (replacement) */
  /* Omit this specialised instruction altogether unless
     replacements are in fact supported in this
     configuration. */
#if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
  JITTER_INSTRUCTION_PROLOG_(!REPLACEMENT-branch-if-positive/fR/fR/retR, _eREPLACEMENT_mbranch_mif_mpositive__fR__fR__retR, cold)
  { /* This block begins with definitions for !REPLACEMENT-branch-if-positive/fR/fR/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       227
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         !REPLACEMENT-branch-if-positive/fR/fR/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "branch-if-positive"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "!REPLACEMENT-branch-if-positive/fR/fR/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _eREPLACEMENT_mbranch_mif_mpositive__fR__fR__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is non-relocatable.
       Its 2-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST JITTER_BRANCH
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
    /* This specialized instruction is non-relocatable.
       Its 2-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 3

  /* Define argument-access macros for !REPLACEMENT-branch-if-positive/fR/fR/retR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

    /* The 2th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG2  JITTER_RESIDUAL_ARGUMENT_2
    JITTER_MARK_RESIDUAL_2_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[2])
#else
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[3])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN2 (JITTER_ARG2.fixnum)
#   define JITTER_ARGU2 (JITTER_ARG2.ufixnum)
#   define JITTER_ARGP2 (JITTER_ARG2.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
    /* The 0th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

    /* The 2th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG2  JITTER_RESIDUAL_ARGUMENT_2
    JITTER_MARK_RESIDUAL_2_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[2])
#else
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[3])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN2 (JITTER_ARG2.fixnum)
#   define JITTER_ARGU2 (JITTER_ARG2.ufixnum)
#   define JITTER_ARGP2 (JITTER_ARG2.pointer)
#   define JITTER_ARGF2 JITTER_ARGP2

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* When jumping to the non-relocatable part it is important not
   to use a fallback version of JITTER_COMPUTED_GOTO, in order to
   prevent GCC from tail-merging. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
    /* Jump to non-relocatable code. */
    JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);

    /* Here the residual arity is given as zero: it's too late to
       skip residuals, since we've already jumped and this code is
       unreachable.  The instruction pointer, if any, is advanced
       in the non-relocatable code. */
    JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-branch-if-positive/fR/fR/retR, _eREPLACEMENT_mbranch_mif_mpositive__fR__fR__retR, 0)

    /* Relocated code will jump to this label in non-relocated code. */
  JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
    JITTER_COMMENT_IN_ASM_("!REPLACEMENT-branch-if-positive/fR/fR/retR non-relocatable code");
#endif // #ifdef JITTER_REPLICATE
#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of !REPLACEMENT-branch-if-positive/fR/fR/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  no. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
//#if 0
  //fprintf (stderr, "Executing instruction %s..\n", "!REPLACEMENT-branch-if-positive/fR/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing replacement instruction %s..\n", "!REPLACEMENT-branch-if-positive/fR/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing non-relocatable instruction %s with JITTER_SPECIALIZED_INSTRUCTION_WORD_NO=%i..\n", "!REPLACEMENT-branch-if-positive/fR/fR/retR", (int) JITTER_SPECIALIZED_INSTRUCTION_WORD_NO); fflush (stderr);
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#undef JITTER_THIS_IS_A_REPLACEMENT
#define JITTER_THIS_IS_A_REPLACEMENT 1

    /* User code for !REPLACEMENT-branch-if-positive/fR/fR/retR . */
  {
/* User-specified code, user code block part: beginning. */

    JITTERLISPVM_CHECK_TYPES_1(FIXNUM, JITTER_ARGF1);
    jitterlisp_object top = JITTER_TOP_MAINSTACK();
    JITTER_DROP_MAINSTACK();
    JITTER_BRANCH_FAST_IF_POSITIVE(top, JITTER_ARGF0);
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for !REPLACEMENT-branch-if-positive/fR/fR/retR . */

  //fprintf (stderr, "..Executed replacement instruction %s\n", "!REPLACEMENT-branch-if-positive/fR/fR/retR");
  //fprintf (stderr, "..Executed instruction %s\n", "!REPLACEMENT-branch-if-positive/fR/fR/retR");
//#endif // #if 0
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
#ifdef JITTER_REPLICATE
  {
    /* Advance the instruction pointer, if any, to skip every
       residual but the last; branch back to replicated
       code. */
    const void *_jitter_back_to_replicated_code_pointer =
      JITTER_ARGP2;
    JITTER_SKIP_RESIDUALS_;
    goto * _jitter_back_to_replicated_code_pointer;
  }
#endif // #ifdef JITTER_REPLICATE

    /* Undefine the !REPLACEMENT-branch-if-positive/fR/fR/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1
#   undef JITTER_SLOW_REGISTER_OFFSET2
#   undef JITTER_ARG2
#   undef JITTER_ARGN2
#   undef JITTER_ARGU2
#   undef JITTER_ARGP2
#   undef JITTER_ARGF2

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#ifndef JITTER_REPLICATE
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-branch-if-positive/fR/fR/retR, _eREPLACEMENT_mbranch_mif_mpositive__fR__fR__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#endif // #ifndef JITTER_REPLICATE
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for !REPLACEMENT-branch-if-positive/fR/fR/retR, which started with its
       definitions. */
  }
#endif // #if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
/*  End of !REPLACEMENT-branch-if-positive/fR/fR/retR , a replacement specialised instruction */

  /* Ordinary specialised instruction !REPLACEMENT-branch-if-register-non-positive/%rR/fR/fR/retR (replacement) */
  /* Omit this specialised instruction altogether unless
     replacements are in fact supported in this
     configuration. */
#if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
  JITTER_INSTRUCTION_PROLOG_(!REPLACEMENT-branch-if-register-non-positive/%rR/fR/fR/retR, _eREPLACEMENT_mbranch_mif_mregister_mnon_mpositive___rrR__fR__fR__retR, cold)
  { /* This block begins with definitions for !REPLACEMENT-branch-if-register-non-positive/%rR/fR/fR/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       228
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         !REPLACEMENT-branch-if-register-non-positive/%rR/fR/fR/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "branch-if-register-non-positive"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "!REPLACEMENT-branch-if-register-non-positive/%rR/fR/fR/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _eREPLACEMENT_mbranch_mif_mregister_mnon_mpositive___rrR__fR__fR__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is non-relocatable.
       Its 3-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST JITTER_BRANCH
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
    /* This specialized instruction is non-relocatable.
       Its 3-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 4

  /* Define argument-access macros for !REPLACEMENT-branch-if-register-non-positive/%rR/fR/fR/retR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a slow (therefore residual, passed as an offset)
        register. */
  /* Define a macro expanding to the slow register offset. */
#if defined(JITTER_DISPATCH_NO_THREADING)
# define JITTER_SLOW_REGISTER_OFFSET0 (JITTER_RESIDUAL_ARGUMENT_0.fixnum)
#elif defined (JITTER_DISPATCH_MINIMAL_THREADING)
# define JITTER_SLOW_REGISTER_OFFSET0 ((((union jitter_word*)jitter_ip)[0]).fixnum)
#else
# define JITTER_SLOW_REGISTER_OFFSET0 ((((union jitter_word*)jitter_ip)[1]).fixnum)
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
  /* Define a macro expanding to an l-value for the VM register content. */
#   define JITTER_ARG0  JITTER_SLOW_REGISTER_FROM_OFFSET(r, JITTER_SLOW_REGISTER_OFFSET0)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

    /* The 2th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG2  JITTER_RESIDUAL_ARGUMENT_2
    JITTER_MARK_RESIDUAL_2_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[2])
#else
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[3])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN2 (JITTER_ARG2.fixnum)
#   define JITTER_ARGU2 (JITTER_ARG2.ufixnum)
#   define JITTER_ARGP2 (JITTER_ARG2.pointer)
#   define JITTER_ARGF2 JITTER_ARGP2

    /* The 3th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG3  JITTER_RESIDUAL_ARGUMENT_3
    JITTER_MARK_RESIDUAL_3_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG3  (((union jitter_word*)jitter_ip)[3])
#else
#   define JITTER_ARG3  (((union jitter_word*)jitter_ip)[4])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN3 (JITTER_ARG3.fixnum)
#   define JITTER_ARGU3 (JITTER_ARG3.ufixnum)
#   define JITTER_ARGP3 (JITTER_ARG3.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
    /* The 0th argument is a slow (therefore residual, passed as an offset)
        register. */
  /* Define a macro expanding to the slow register offset. */
#if defined(JITTER_DISPATCH_NO_THREADING)
# define JITTER_SLOW_REGISTER_OFFSET0 (JITTER_RESIDUAL_ARGUMENT_0.fixnum)
#elif defined (JITTER_DISPATCH_MINIMAL_THREADING)
# define JITTER_SLOW_REGISTER_OFFSET0 ((((union jitter_word*)jitter_ip)[0]).fixnum)
#else
# define JITTER_SLOW_REGISTER_OFFSET0 ((((union jitter_word*)jitter_ip)[1]).fixnum)
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
  /* Define a macro expanding to an l-value for the VM register content. */
#   define JITTER_ARG0  JITTER_SLOW_REGISTER_FROM_OFFSET(r, JITTER_SLOW_REGISTER_OFFSET0)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

    /* The 2th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG2  JITTER_RESIDUAL_ARGUMENT_2
    JITTER_MARK_RESIDUAL_2_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[2])
#else
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[3])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN2 (JITTER_ARG2.fixnum)
#   define JITTER_ARGU2 (JITTER_ARG2.ufixnum)
#   define JITTER_ARGP2 (JITTER_ARG2.pointer)
#   define JITTER_ARGF2 JITTER_ARGP2

    /* The 3th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG3  JITTER_RESIDUAL_ARGUMENT_3
    JITTER_MARK_RESIDUAL_3_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG3  (((union jitter_word*)jitter_ip)[3])
#else
#   define JITTER_ARG3  (((union jitter_word*)jitter_ip)[4])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN3 (JITTER_ARG3.fixnum)
#   define JITTER_ARGU3 (JITTER_ARG3.ufixnum)
#   define JITTER_ARGP3 (JITTER_ARG3.pointer)
#   define JITTER_ARGF3 JITTER_ARGP3

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* When jumping to the non-relocatable part it is important not
   to use a fallback version of JITTER_COMPUTED_GOTO, in order to
   prevent GCC from tail-merging. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
    /* Jump to non-relocatable code. */
    JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);

    /* Here the residual arity is given as zero: it's too late to
       skip residuals, since we've already jumped and this code is
       unreachable.  The instruction pointer, if any, is advanced
       in the non-relocatable code. */
    JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-branch-if-register-non-positive/%rR/fR/fR/retR, _eREPLACEMENT_mbranch_mif_mregister_mnon_mpositive___rrR__fR__fR__retR, 0)

    /* Relocated code will jump to this label in non-relocated code. */
  JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
    JITTER_COMMENT_IN_ASM_("!REPLACEMENT-branch-if-register-non-positive/%rR/fR/fR/retR non-relocatable code");
#endif // #ifdef JITTER_REPLICATE
#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of !REPLACEMENT-branch-if-register-non-positive/%rR/fR/fR/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  no. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
//#if 0
  //fprintf (stderr, "Executing instruction %s..\n", "!REPLACEMENT-branch-if-register-non-positive/%rR/fR/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing replacement instruction %s..\n", "!REPLACEMENT-branch-if-register-non-positive/%rR/fR/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing non-relocatable instruction %s with JITTER_SPECIALIZED_INSTRUCTION_WORD_NO=%i..\n", "!REPLACEMENT-branch-if-register-non-positive/%rR/fR/fR/retR", (int) JITTER_SPECIALIZED_INSTRUCTION_WORD_NO); fflush (stderr);
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#undef JITTER_THIS_IS_A_REPLACEMENT
#define JITTER_THIS_IS_A_REPLACEMENT 1

    /* User code for !REPLACEMENT-branch-if-register-non-positive/%rR/fR/fR/retR . */
  {
/* User-specified code, user code block part: beginning. */

#if ! defined (JITTERLISP_UNSAFE)
    JITTERLISP_BRANCH_FAST_UNLESS_FIXNUM (JITTER_ARG0, JITTER_ARGF2);
#endif
    JITTER_BRANCH_FAST_IF_NONPOSITIVE(JITTER_ARG0, JITTER_ARGF1);
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for !REPLACEMENT-branch-if-register-non-positive/%rR/fR/fR/retR . */

  //fprintf (stderr, "..Executed replacement instruction %s\n", "!REPLACEMENT-branch-if-register-non-positive/%rR/fR/fR/retR");
  //fprintf (stderr, "..Executed instruction %s\n", "!REPLACEMENT-branch-if-register-non-positive/%rR/fR/fR/retR");
//#endif // #if 0
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
#ifdef JITTER_REPLICATE
  {
    /* Advance the instruction pointer, if any, to skip every
       residual but the last; branch back to replicated
       code. */
    const void *_jitter_back_to_replicated_code_pointer =
      JITTER_ARGP3;
    JITTER_SKIP_RESIDUALS_;
    goto * _jitter_back_to_replicated_code_pointer;
  }
#endif // #ifdef JITTER_REPLICATE

    /* Undefine the !REPLACEMENT-branch-if-register-non-positive/%rR/fR/fR/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1
#   undef JITTER_SLOW_REGISTER_OFFSET2
#   undef JITTER_ARG2
#   undef JITTER_ARGN2
#   undef JITTER_ARGU2
#   undef JITTER_ARGP2
#   undef JITTER_ARGF2
#   undef JITTER_SLOW_REGISTER_OFFSET3
#   undef JITTER_ARG3
#   undef JITTER_ARGN3
#   undef JITTER_ARGU3
#   undef JITTER_ARGP3
#   undef JITTER_ARGF3

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#ifndef JITTER_REPLICATE
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-branch-if-register-non-positive/%rR/fR/fR/retR, _eREPLACEMENT_mbranch_mif_mregister_mnon_mpositive___rrR__fR__fR__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#endif // #ifndef JITTER_REPLICATE
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for !REPLACEMENT-branch-if-register-non-positive/%rR/fR/fR/retR, which started with its
       definitions. */
  }
#endif // #if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
/*  End of !REPLACEMENT-branch-if-register-non-positive/%rR/fR/fR/retR , a replacement specialised instruction */

  /* Ordinary specialised instruction !REPLACEMENT-branch-if-register-non-zero/%rR/fR/fR/retR (replacement) */
  /* Omit this specialised instruction altogether unless
     replacements are in fact supported in this
     configuration. */
#if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
  JITTER_INSTRUCTION_PROLOG_(!REPLACEMENT-branch-if-register-non-zero/%rR/fR/fR/retR, _eREPLACEMENT_mbranch_mif_mregister_mnon_mzero___rrR__fR__fR__retR, cold)
  { /* This block begins with definitions for !REPLACEMENT-branch-if-register-non-zero/%rR/fR/fR/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       229
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         !REPLACEMENT-branch-if-register-non-zero/%rR/fR/fR/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "branch-if-register-non-zero"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "!REPLACEMENT-branch-if-register-non-zero/%rR/fR/fR/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _eREPLACEMENT_mbranch_mif_mregister_mnon_mzero___rrR__fR__fR__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is non-relocatable.
       Its 3-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST JITTER_BRANCH
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
    /* This specialized instruction is non-relocatable.
       Its 3-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 4

  /* Define argument-access macros for !REPLACEMENT-branch-if-register-non-zero/%rR/fR/fR/retR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a slow (therefore residual, passed as an offset)
        register. */
  /* Define a macro expanding to the slow register offset. */
#if defined(JITTER_DISPATCH_NO_THREADING)
# define JITTER_SLOW_REGISTER_OFFSET0 (JITTER_RESIDUAL_ARGUMENT_0.fixnum)
#elif defined (JITTER_DISPATCH_MINIMAL_THREADING)
# define JITTER_SLOW_REGISTER_OFFSET0 ((((union jitter_word*)jitter_ip)[0]).fixnum)
#else
# define JITTER_SLOW_REGISTER_OFFSET0 ((((union jitter_word*)jitter_ip)[1]).fixnum)
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
  /* Define a macro expanding to an l-value for the VM register content. */
#   define JITTER_ARG0  JITTER_SLOW_REGISTER_FROM_OFFSET(r, JITTER_SLOW_REGISTER_OFFSET0)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

    /* The 2th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG2  JITTER_RESIDUAL_ARGUMENT_2
    JITTER_MARK_RESIDUAL_2_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[2])
#else
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[3])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN2 (JITTER_ARG2.fixnum)
#   define JITTER_ARGU2 (JITTER_ARG2.ufixnum)
#   define JITTER_ARGP2 (JITTER_ARG2.pointer)
#   define JITTER_ARGF2 JITTER_ARGP2

    /* The 3th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG3  JITTER_RESIDUAL_ARGUMENT_3
    JITTER_MARK_RESIDUAL_3_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG3  (((union jitter_word*)jitter_ip)[3])
#else
#   define JITTER_ARG3  (((union jitter_word*)jitter_ip)[4])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN3 (JITTER_ARG3.fixnum)
#   define JITTER_ARGU3 (JITTER_ARG3.ufixnum)
#   define JITTER_ARGP3 (JITTER_ARG3.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
    /* The 0th argument is a slow (therefore residual, passed as an offset)
        register. */
  /* Define a macro expanding to the slow register offset. */
#if defined(JITTER_DISPATCH_NO_THREADING)
# define JITTER_SLOW_REGISTER_OFFSET0 (JITTER_RESIDUAL_ARGUMENT_0.fixnum)
#elif defined (JITTER_DISPATCH_MINIMAL_THREADING)
# define JITTER_SLOW_REGISTER_OFFSET0 ((((union jitter_word*)jitter_ip)[0]).fixnum)
#else
# define JITTER_SLOW_REGISTER_OFFSET0 ((((union jitter_word*)jitter_ip)[1]).fixnum)
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
  /* Define a macro expanding to an l-value for the VM register content. */
#   define JITTER_ARG0  JITTER_SLOW_REGISTER_FROM_OFFSET(r, JITTER_SLOW_REGISTER_OFFSET0)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

    /* The 2th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG2  JITTER_RESIDUAL_ARGUMENT_2
    JITTER_MARK_RESIDUAL_2_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[2])
#else
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[3])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN2 (JITTER_ARG2.fixnum)
#   define JITTER_ARGU2 (JITTER_ARG2.ufixnum)
#   define JITTER_ARGP2 (JITTER_ARG2.pointer)
#   define JITTER_ARGF2 JITTER_ARGP2

    /* The 3th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG3  JITTER_RESIDUAL_ARGUMENT_3
    JITTER_MARK_RESIDUAL_3_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG3  (((union jitter_word*)jitter_ip)[3])
#else
#   define JITTER_ARG3  (((union jitter_word*)jitter_ip)[4])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN3 (JITTER_ARG3.fixnum)
#   define JITTER_ARGU3 (JITTER_ARG3.ufixnum)
#   define JITTER_ARGP3 (JITTER_ARG3.pointer)
#   define JITTER_ARGF3 JITTER_ARGP3

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* When jumping to the non-relocatable part it is important not
   to use a fallback version of JITTER_COMPUTED_GOTO, in order to
   prevent GCC from tail-merging. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
    /* Jump to non-relocatable code. */
    JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);

    /* Here the residual arity is given as zero: it's too late to
       skip residuals, since we've already jumped and this code is
       unreachable.  The instruction pointer, if any, is advanced
       in the non-relocatable code. */
    JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-branch-if-register-non-zero/%rR/fR/fR/retR, _eREPLACEMENT_mbranch_mif_mregister_mnon_mzero___rrR__fR__fR__retR, 0)

    /* Relocated code will jump to this label in non-relocated code. */
  JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
    JITTER_COMMENT_IN_ASM_("!REPLACEMENT-branch-if-register-non-zero/%rR/fR/fR/retR non-relocatable code");
#endif // #ifdef JITTER_REPLICATE
#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of !REPLACEMENT-branch-if-register-non-zero/%rR/fR/fR/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  no. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
//#if 0
  //fprintf (stderr, "Executing instruction %s..\n", "!REPLACEMENT-branch-if-register-non-zero/%rR/fR/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing replacement instruction %s..\n", "!REPLACEMENT-branch-if-register-non-zero/%rR/fR/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing non-relocatable instruction %s with JITTER_SPECIALIZED_INSTRUCTION_WORD_NO=%i..\n", "!REPLACEMENT-branch-if-register-non-zero/%rR/fR/fR/retR", (int) JITTER_SPECIALIZED_INSTRUCTION_WORD_NO); fflush (stderr);
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#undef JITTER_THIS_IS_A_REPLACEMENT
#define JITTER_THIS_IS_A_REPLACEMENT 1

    /* User code for !REPLACEMENT-branch-if-register-non-zero/%rR/fR/fR/retR . */
  {
/* User-specified code, user code block part: beginning. */

#if ! defined (JITTERLISP_UNSAFE)
    JITTERLISP_BRANCH_FAST_UNLESS_FIXNUM (JITTER_ARG0, JITTER_ARGF2);
#endif
    JITTER_BRANCH_FAST_IF_NOTEQUAL(JITTER_ARG0, JITTERLISP_FIXNUM_ENCODE(0),
                                   JITTER_ARGF1);
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for !REPLACEMENT-branch-if-register-non-zero/%rR/fR/fR/retR . */

  //fprintf (stderr, "..Executed replacement instruction %s\n", "!REPLACEMENT-branch-if-register-non-zero/%rR/fR/fR/retR");
  //fprintf (stderr, "..Executed instruction %s\n", "!REPLACEMENT-branch-if-register-non-zero/%rR/fR/fR/retR");
//#endif // #if 0
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
#ifdef JITTER_REPLICATE
  {
    /* Advance the instruction pointer, if any, to skip every
       residual but the last; branch back to replicated
       code. */
    const void *_jitter_back_to_replicated_code_pointer =
      JITTER_ARGP3;
    JITTER_SKIP_RESIDUALS_;
    goto * _jitter_back_to_replicated_code_pointer;
  }
#endif // #ifdef JITTER_REPLICATE

    /* Undefine the !REPLACEMENT-branch-if-register-non-zero/%rR/fR/fR/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1
#   undef JITTER_SLOW_REGISTER_OFFSET2
#   undef JITTER_ARG2
#   undef JITTER_ARGN2
#   undef JITTER_ARGU2
#   undef JITTER_ARGP2
#   undef JITTER_ARGF2
#   undef JITTER_SLOW_REGISTER_OFFSET3
#   undef JITTER_ARG3
#   undef JITTER_ARGN3
#   undef JITTER_ARGU3
#   undef JITTER_ARGP3
#   undef JITTER_ARGF3

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#ifndef JITTER_REPLICATE
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-branch-if-register-non-zero/%rR/fR/fR/retR, _eREPLACEMENT_mbranch_mif_mregister_mnon_mzero___rrR__fR__fR__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#endif // #ifndef JITTER_REPLICATE
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for !REPLACEMENT-branch-if-register-non-zero/%rR/fR/fR/retR, which started with its
       definitions. */
  }
#endif // #if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
/*  End of !REPLACEMENT-branch-if-register-non-zero/%rR/fR/fR/retR , a replacement specialised instruction */

  /* Ordinary specialised instruction !REPLACEMENT-branch-if-register-not-null/%rR/fR/retR (replacement) */
  /* Omit this specialised instruction altogether unless
     replacements are in fact supported in this
     configuration. */
#if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
  JITTER_INSTRUCTION_PROLOG_(!REPLACEMENT-branch-if-register-not-null/%rR/fR/retR, _eREPLACEMENT_mbranch_mif_mregister_mnot_mnull___rrR__fR__retR, cold)
  { /* This block begins with definitions for !REPLACEMENT-branch-if-register-not-null/%rR/fR/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       230
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         !REPLACEMENT-branch-if-register-not-null/%rR/fR/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "branch-if-register-not-null"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "!REPLACEMENT-branch-if-register-not-null/%rR/fR/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _eREPLACEMENT_mbranch_mif_mregister_mnot_mnull___rrR__fR__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is non-relocatable.
       Its 2-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST JITTER_BRANCH
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
    /* This specialized instruction is non-relocatable.
       Its 2-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 3

  /* Define argument-access macros for !REPLACEMENT-branch-if-register-not-null/%rR/fR/retR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a slow (therefore residual, passed as an offset)
        register. */
  /* Define a macro expanding to the slow register offset. */
#if defined(JITTER_DISPATCH_NO_THREADING)
# define JITTER_SLOW_REGISTER_OFFSET0 (JITTER_RESIDUAL_ARGUMENT_0.fixnum)
#elif defined (JITTER_DISPATCH_MINIMAL_THREADING)
# define JITTER_SLOW_REGISTER_OFFSET0 ((((union jitter_word*)jitter_ip)[0]).fixnum)
#else
# define JITTER_SLOW_REGISTER_OFFSET0 ((((union jitter_word*)jitter_ip)[1]).fixnum)
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
  /* Define a macro expanding to an l-value for the VM register content. */
#   define JITTER_ARG0  JITTER_SLOW_REGISTER_FROM_OFFSET(r, JITTER_SLOW_REGISTER_OFFSET0)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

    /* The 2th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG2  JITTER_RESIDUAL_ARGUMENT_2
    JITTER_MARK_RESIDUAL_2_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[2])
#else
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[3])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN2 (JITTER_ARG2.fixnum)
#   define JITTER_ARGU2 (JITTER_ARG2.ufixnum)
#   define JITTER_ARGP2 (JITTER_ARG2.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
    /* The 0th argument is a slow (therefore residual, passed as an offset)
        register. */
  /* Define a macro expanding to the slow register offset. */
#if defined(JITTER_DISPATCH_NO_THREADING)
# define JITTER_SLOW_REGISTER_OFFSET0 (JITTER_RESIDUAL_ARGUMENT_0.fixnum)
#elif defined (JITTER_DISPATCH_MINIMAL_THREADING)
# define JITTER_SLOW_REGISTER_OFFSET0 ((((union jitter_word*)jitter_ip)[0]).fixnum)
#else
# define JITTER_SLOW_REGISTER_OFFSET0 ((((union jitter_word*)jitter_ip)[1]).fixnum)
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
  /* Define a macro expanding to an l-value for the VM register content. */
#   define JITTER_ARG0  JITTER_SLOW_REGISTER_FROM_OFFSET(r, JITTER_SLOW_REGISTER_OFFSET0)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

    /* The 2th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG2  JITTER_RESIDUAL_ARGUMENT_2
    JITTER_MARK_RESIDUAL_2_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[2])
#else
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[3])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN2 (JITTER_ARG2.fixnum)
#   define JITTER_ARGU2 (JITTER_ARG2.ufixnum)
#   define JITTER_ARGP2 (JITTER_ARG2.pointer)
#   define JITTER_ARGF2 JITTER_ARGP2

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* When jumping to the non-relocatable part it is important not
   to use a fallback version of JITTER_COMPUTED_GOTO, in order to
   prevent GCC from tail-merging. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
    /* Jump to non-relocatable code. */
    JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);

    /* Here the residual arity is given as zero: it's too late to
       skip residuals, since we've already jumped and this code is
       unreachable.  The instruction pointer, if any, is advanced
       in the non-relocatable code. */
    JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-branch-if-register-not-null/%rR/fR/retR, _eREPLACEMENT_mbranch_mif_mregister_mnot_mnull___rrR__fR__retR, 0)

    /* Relocated code will jump to this label in non-relocated code. */
  JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
    JITTER_COMMENT_IN_ASM_("!REPLACEMENT-branch-if-register-not-null/%rR/fR/retR non-relocatable code");
#endif // #ifdef JITTER_REPLICATE
#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of !REPLACEMENT-branch-if-register-not-null/%rR/fR/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  no. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
//#if 0
  //fprintf (stderr, "Executing instruction %s..\n", "!REPLACEMENT-branch-if-register-not-null/%rR/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing replacement instruction %s..\n", "!REPLACEMENT-branch-if-register-not-null/%rR/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing non-relocatable instruction %s with JITTER_SPECIALIZED_INSTRUCTION_WORD_NO=%i..\n", "!REPLACEMENT-branch-if-register-not-null/%rR/fR/retR", (int) JITTER_SPECIALIZED_INSTRUCTION_WORD_NO); fflush (stderr);
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#undef JITTER_THIS_IS_A_REPLACEMENT
#define JITTER_THIS_IS_A_REPLACEMENT 1

    /* User code for !REPLACEMENT-branch-if-register-not-null/%rR/fR/retR . */
  {
/* User-specified code, user code block part: beginning. */

    JITTER_BRANCH_FAST_IF_NOTEQUAL(JITTER_ARG0,
                                   JITTERLISP_EMPTY_LIST,
                                   JITTER_ARGF1);
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for !REPLACEMENT-branch-if-register-not-null/%rR/fR/retR . */

  //fprintf (stderr, "..Executed replacement instruction %s\n", "!REPLACEMENT-branch-if-register-not-null/%rR/fR/retR");
  //fprintf (stderr, "..Executed instruction %s\n", "!REPLACEMENT-branch-if-register-not-null/%rR/fR/retR");
//#endif // #if 0
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
#ifdef JITTER_REPLICATE
  {
    /* Advance the instruction pointer, if any, to skip every
       residual but the last; branch back to replicated
       code. */
    const void *_jitter_back_to_replicated_code_pointer =
      JITTER_ARGP2;
    JITTER_SKIP_RESIDUALS_;
    goto * _jitter_back_to_replicated_code_pointer;
  }
#endif // #ifdef JITTER_REPLICATE

    /* Undefine the !REPLACEMENT-branch-if-register-not-null/%rR/fR/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1
#   undef JITTER_SLOW_REGISTER_OFFSET2
#   undef JITTER_ARG2
#   undef JITTER_ARGN2
#   undef JITTER_ARGU2
#   undef JITTER_ARGP2
#   undef JITTER_ARGF2

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#ifndef JITTER_REPLICATE
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-branch-if-register-not-null/%rR/fR/retR, _eREPLACEMENT_mbranch_mif_mregister_mnot_mnull___rrR__fR__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#endif // #ifndef JITTER_REPLICATE
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for !REPLACEMENT-branch-if-register-not-null/%rR/fR/retR, which started with its
       definitions. */
  }
#endif // #if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
/*  End of !REPLACEMENT-branch-if-register-not-null/%rR/fR/retR , a replacement specialised instruction */

  /* Ordinary specialised instruction !REPLACEMENT-branch-if-register-null/%rR/fR/retR (replacement) */
  /* Omit this specialised instruction altogether unless
     replacements are in fact supported in this
     configuration. */
#if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
  JITTER_INSTRUCTION_PROLOG_(!REPLACEMENT-branch-if-register-null/%rR/fR/retR, _eREPLACEMENT_mbranch_mif_mregister_mnull___rrR__fR__retR, cold)
  { /* This block begins with definitions for !REPLACEMENT-branch-if-register-null/%rR/fR/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       231
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         !REPLACEMENT-branch-if-register-null/%rR/fR/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "branch-if-register-null"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "!REPLACEMENT-branch-if-register-null/%rR/fR/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _eREPLACEMENT_mbranch_mif_mregister_mnull___rrR__fR__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is non-relocatable.
       Its 2-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST JITTER_BRANCH
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
    /* This specialized instruction is non-relocatable.
       Its 2-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 3

  /* Define argument-access macros for !REPLACEMENT-branch-if-register-null/%rR/fR/retR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a slow (therefore residual, passed as an offset)
        register. */
  /* Define a macro expanding to the slow register offset. */
#if defined(JITTER_DISPATCH_NO_THREADING)
# define JITTER_SLOW_REGISTER_OFFSET0 (JITTER_RESIDUAL_ARGUMENT_0.fixnum)
#elif defined (JITTER_DISPATCH_MINIMAL_THREADING)
# define JITTER_SLOW_REGISTER_OFFSET0 ((((union jitter_word*)jitter_ip)[0]).fixnum)
#else
# define JITTER_SLOW_REGISTER_OFFSET0 ((((union jitter_word*)jitter_ip)[1]).fixnum)
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
  /* Define a macro expanding to an l-value for the VM register content. */
#   define JITTER_ARG0  JITTER_SLOW_REGISTER_FROM_OFFSET(r, JITTER_SLOW_REGISTER_OFFSET0)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

    /* The 2th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG2  JITTER_RESIDUAL_ARGUMENT_2
    JITTER_MARK_RESIDUAL_2_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[2])
#else
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[3])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN2 (JITTER_ARG2.fixnum)
#   define JITTER_ARGU2 (JITTER_ARG2.ufixnum)
#   define JITTER_ARGP2 (JITTER_ARG2.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
    /* The 0th argument is a slow (therefore residual, passed as an offset)
        register. */
  /* Define a macro expanding to the slow register offset. */
#if defined(JITTER_DISPATCH_NO_THREADING)
# define JITTER_SLOW_REGISTER_OFFSET0 (JITTER_RESIDUAL_ARGUMENT_0.fixnum)
#elif defined (JITTER_DISPATCH_MINIMAL_THREADING)
# define JITTER_SLOW_REGISTER_OFFSET0 ((((union jitter_word*)jitter_ip)[0]).fixnum)
#else
# define JITTER_SLOW_REGISTER_OFFSET0 ((((union jitter_word*)jitter_ip)[1]).fixnum)
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
  /* Define a macro expanding to an l-value for the VM register content. */
#   define JITTER_ARG0  JITTER_SLOW_REGISTER_FROM_OFFSET(r, JITTER_SLOW_REGISTER_OFFSET0)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

    /* The 2th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG2  JITTER_RESIDUAL_ARGUMENT_2
    JITTER_MARK_RESIDUAL_2_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[2])
#else
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[3])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN2 (JITTER_ARG2.fixnum)
#   define JITTER_ARGU2 (JITTER_ARG2.ufixnum)
#   define JITTER_ARGP2 (JITTER_ARG2.pointer)
#   define JITTER_ARGF2 JITTER_ARGP2

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* When jumping to the non-relocatable part it is important not
   to use a fallback version of JITTER_COMPUTED_GOTO, in order to
   prevent GCC from tail-merging. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
    /* Jump to non-relocatable code. */
    JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);

    /* Here the residual arity is given as zero: it's too late to
       skip residuals, since we've already jumped and this code is
       unreachable.  The instruction pointer, if any, is advanced
       in the non-relocatable code. */
    JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-branch-if-register-null/%rR/fR/retR, _eREPLACEMENT_mbranch_mif_mregister_mnull___rrR__fR__retR, 0)

    /* Relocated code will jump to this label in non-relocated code. */
  JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
    JITTER_COMMENT_IN_ASM_("!REPLACEMENT-branch-if-register-null/%rR/fR/retR non-relocatable code");
#endif // #ifdef JITTER_REPLICATE
#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of !REPLACEMENT-branch-if-register-null/%rR/fR/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  no. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
//#if 0
  //fprintf (stderr, "Executing instruction %s..\n", "!REPLACEMENT-branch-if-register-null/%rR/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing replacement instruction %s..\n", "!REPLACEMENT-branch-if-register-null/%rR/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing non-relocatable instruction %s with JITTER_SPECIALIZED_INSTRUCTION_WORD_NO=%i..\n", "!REPLACEMENT-branch-if-register-null/%rR/fR/retR", (int) JITTER_SPECIALIZED_INSTRUCTION_WORD_NO); fflush (stderr);
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#undef JITTER_THIS_IS_A_REPLACEMENT
#define JITTER_THIS_IS_A_REPLACEMENT 1

    /* User code for !REPLACEMENT-branch-if-register-null/%rR/fR/retR . */
  {
/* User-specified code, user code block part: beginning. */

    JITTER_BRANCH_FAST_IF_EQUAL(JITTER_ARG0,
                                JITTERLISP_EMPTY_LIST,
                                JITTER_ARGF1);
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for !REPLACEMENT-branch-if-register-null/%rR/fR/retR . */

  //fprintf (stderr, "..Executed replacement instruction %s\n", "!REPLACEMENT-branch-if-register-null/%rR/fR/retR");
  //fprintf (stderr, "..Executed instruction %s\n", "!REPLACEMENT-branch-if-register-null/%rR/fR/retR");
//#endif // #if 0
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
#ifdef JITTER_REPLICATE
  {
    /* Advance the instruction pointer, if any, to skip every
       residual but the last; branch back to replicated
       code. */
    const void *_jitter_back_to_replicated_code_pointer =
      JITTER_ARGP2;
    JITTER_SKIP_RESIDUALS_;
    goto * _jitter_back_to_replicated_code_pointer;
  }
#endif // #ifdef JITTER_REPLICATE

    /* Undefine the !REPLACEMENT-branch-if-register-null/%rR/fR/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1
#   undef JITTER_SLOW_REGISTER_OFFSET2
#   undef JITTER_ARG2
#   undef JITTER_ARGN2
#   undef JITTER_ARGU2
#   undef JITTER_ARGP2
#   undef JITTER_ARGF2

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#ifndef JITTER_REPLICATE
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-branch-if-register-null/%rR/fR/retR, _eREPLACEMENT_mbranch_mif_mregister_mnull___rrR__fR__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#endif // #ifndef JITTER_REPLICATE
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for !REPLACEMENT-branch-if-register-null/%rR/fR/retR, which started with its
       definitions. */
  }
#endif // #if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
/*  End of !REPLACEMENT-branch-if-register-null/%rR/fR/retR , a replacement specialised instruction */

  /* Ordinary specialised instruction !REPLACEMENT-branch-if-register-positive/%rR/fR/fR/retR (replacement) */
  /* Omit this specialised instruction altogether unless
     replacements are in fact supported in this
     configuration. */
#if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
  JITTER_INSTRUCTION_PROLOG_(!REPLACEMENT-branch-if-register-positive/%rR/fR/fR/retR, _eREPLACEMENT_mbranch_mif_mregister_mpositive___rrR__fR__fR__retR, cold)
  { /* This block begins with definitions for !REPLACEMENT-branch-if-register-positive/%rR/fR/fR/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       232
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         !REPLACEMENT-branch-if-register-positive/%rR/fR/fR/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "branch-if-register-positive"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "!REPLACEMENT-branch-if-register-positive/%rR/fR/fR/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _eREPLACEMENT_mbranch_mif_mregister_mpositive___rrR__fR__fR__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is non-relocatable.
       Its 3-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST JITTER_BRANCH
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
    /* This specialized instruction is non-relocatable.
       Its 3-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 4

  /* Define argument-access macros for !REPLACEMENT-branch-if-register-positive/%rR/fR/fR/retR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a slow (therefore residual, passed as an offset)
        register. */
  /* Define a macro expanding to the slow register offset. */
#if defined(JITTER_DISPATCH_NO_THREADING)
# define JITTER_SLOW_REGISTER_OFFSET0 (JITTER_RESIDUAL_ARGUMENT_0.fixnum)
#elif defined (JITTER_DISPATCH_MINIMAL_THREADING)
# define JITTER_SLOW_REGISTER_OFFSET0 ((((union jitter_word*)jitter_ip)[0]).fixnum)
#else
# define JITTER_SLOW_REGISTER_OFFSET0 ((((union jitter_word*)jitter_ip)[1]).fixnum)
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
  /* Define a macro expanding to an l-value for the VM register content. */
#   define JITTER_ARG0  JITTER_SLOW_REGISTER_FROM_OFFSET(r, JITTER_SLOW_REGISTER_OFFSET0)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

    /* The 2th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG2  JITTER_RESIDUAL_ARGUMENT_2
    JITTER_MARK_RESIDUAL_2_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[2])
#else
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[3])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN2 (JITTER_ARG2.fixnum)
#   define JITTER_ARGU2 (JITTER_ARG2.ufixnum)
#   define JITTER_ARGP2 (JITTER_ARG2.pointer)
#   define JITTER_ARGF2 JITTER_ARGP2

    /* The 3th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG3  JITTER_RESIDUAL_ARGUMENT_3
    JITTER_MARK_RESIDUAL_3_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG3  (((union jitter_word*)jitter_ip)[3])
#else
#   define JITTER_ARG3  (((union jitter_word*)jitter_ip)[4])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN3 (JITTER_ARG3.fixnum)
#   define JITTER_ARGU3 (JITTER_ARG3.ufixnum)
#   define JITTER_ARGP3 (JITTER_ARG3.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
    /* The 0th argument is a slow (therefore residual, passed as an offset)
        register. */
  /* Define a macro expanding to the slow register offset. */
#if defined(JITTER_DISPATCH_NO_THREADING)
# define JITTER_SLOW_REGISTER_OFFSET0 (JITTER_RESIDUAL_ARGUMENT_0.fixnum)
#elif defined (JITTER_DISPATCH_MINIMAL_THREADING)
# define JITTER_SLOW_REGISTER_OFFSET0 ((((union jitter_word*)jitter_ip)[0]).fixnum)
#else
# define JITTER_SLOW_REGISTER_OFFSET0 ((((union jitter_word*)jitter_ip)[1]).fixnum)
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
  /* Define a macro expanding to an l-value for the VM register content. */
#   define JITTER_ARG0  JITTER_SLOW_REGISTER_FROM_OFFSET(r, JITTER_SLOW_REGISTER_OFFSET0)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

    /* The 2th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG2  JITTER_RESIDUAL_ARGUMENT_2
    JITTER_MARK_RESIDUAL_2_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[2])
#else
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[3])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN2 (JITTER_ARG2.fixnum)
#   define JITTER_ARGU2 (JITTER_ARG2.ufixnum)
#   define JITTER_ARGP2 (JITTER_ARG2.pointer)
#   define JITTER_ARGF2 JITTER_ARGP2

    /* The 3th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG3  JITTER_RESIDUAL_ARGUMENT_3
    JITTER_MARK_RESIDUAL_3_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG3  (((union jitter_word*)jitter_ip)[3])
#else
#   define JITTER_ARG3  (((union jitter_word*)jitter_ip)[4])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN3 (JITTER_ARG3.fixnum)
#   define JITTER_ARGU3 (JITTER_ARG3.ufixnum)
#   define JITTER_ARGP3 (JITTER_ARG3.pointer)
#   define JITTER_ARGF3 JITTER_ARGP3

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* When jumping to the non-relocatable part it is important not
   to use a fallback version of JITTER_COMPUTED_GOTO, in order to
   prevent GCC from tail-merging. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
    /* Jump to non-relocatable code. */
    JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);

    /* Here the residual arity is given as zero: it's too late to
       skip residuals, since we've already jumped and this code is
       unreachable.  The instruction pointer, if any, is advanced
       in the non-relocatable code. */
    JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-branch-if-register-positive/%rR/fR/fR/retR, _eREPLACEMENT_mbranch_mif_mregister_mpositive___rrR__fR__fR__retR, 0)

    /* Relocated code will jump to this label in non-relocated code. */
  JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
    JITTER_COMMENT_IN_ASM_("!REPLACEMENT-branch-if-register-positive/%rR/fR/fR/retR non-relocatable code");
#endif // #ifdef JITTER_REPLICATE
#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of !REPLACEMENT-branch-if-register-positive/%rR/fR/fR/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  no. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
//#if 0
  //fprintf (stderr, "Executing instruction %s..\n", "!REPLACEMENT-branch-if-register-positive/%rR/fR/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing replacement instruction %s..\n", "!REPLACEMENT-branch-if-register-positive/%rR/fR/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing non-relocatable instruction %s with JITTER_SPECIALIZED_INSTRUCTION_WORD_NO=%i..\n", "!REPLACEMENT-branch-if-register-positive/%rR/fR/fR/retR", (int) JITTER_SPECIALIZED_INSTRUCTION_WORD_NO); fflush (stderr);
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#undef JITTER_THIS_IS_A_REPLACEMENT
#define JITTER_THIS_IS_A_REPLACEMENT 1

    /* User code for !REPLACEMENT-branch-if-register-positive/%rR/fR/fR/retR . */
  {
/* User-specified code, user code block part: beginning. */

#if ! defined (JITTERLISP_UNSAFE)
    JITTERLISP_BRANCH_FAST_UNLESS_FIXNUM (JITTER_ARG0, JITTER_ARGF2);
#endif
    JITTER_BRANCH_FAST_IF_POSITIVE(JITTER_ARG0, JITTER_ARGF1);
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for !REPLACEMENT-branch-if-register-positive/%rR/fR/fR/retR . */

  //fprintf (stderr, "..Executed replacement instruction %s\n", "!REPLACEMENT-branch-if-register-positive/%rR/fR/fR/retR");
  //fprintf (stderr, "..Executed instruction %s\n", "!REPLACEMENT-branch-if-register-positive/%rR/fR/fR/retR");
//#endif // #if 0
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
#ifdef JITTER_REPLICATE
  {
    /* Advance the instruction pointer, if any, to skip every
       residual but the last; branch back to replicated
       code. */
    const void *_jitter_back_to_replicated_code_pointer =
      JITTER_ARGP3;
    JITTER_SKIP_RESIDUALS_;
    goto * _jitter_back_to_replicated_code_pointer;
  }
#endif // #ifdef JITTER_REPLICATE

    /* Undefine the !REPLACEMENT-branch-if-register-positive/%rR/fR/fR/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1
#   undef JITTER_SLOW_REGISTER_OFFSET2
#   undef JITTER_ARG2
#   undef JITTER_ARGN2
#   undef JITTER_ARGU2
#   undef JITTER_ARGP2
#   undef JITTER_ARGF2
#   undef JITTER_SLOW_REGISTER_OFFSET3
#   undef JITTER_ARG3
#   undef JITTER_ARGN3
#   undef JITTER_ARGU3
#   undef JITTER_ARGP3
#   undef JITTER_ARGF3

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#ifndef JITTER_REPLICATE
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-branch-if-register-positive/%rR/fR/fR/retR, _eREPLACEMENT_mbranch_mif_mregister_mpositive___rrR__fR__fR__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#endif // #ifndef JITTER_REPLICATE
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for !REPLACEMENT-branch-if-register-positive/%rR/fR/fR/retR, which started with its
       definitions. */
  }
#endif // #if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
/*  End of !REPLACEMENT-branch-if-register-positive/%rR/fR/fR/retR , a replacement specialised instruction */

  /* Ordinary specialised instruction !REPLACEMENT-branch-if-true/fR/retR (replacement) */
  /* Omit this specialised instruction altogether unless
     replacements are in fact supported in this
     configuration. */
#if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
  JITTER_INSTRUCTION_PROLOG_(!REPLACEMENT-branch-if-true/fR/retR, _eREPLACEMENT_mbranch_mif_mtrue__fR__retR, cold)
  { /* This block begins with definitions for !REPLACEMENT-branch-if-true/fR/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       233
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         !REPLACEMENT-branch-if-true/fR/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "branch-if-true"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "!REPLACEMENT-branch-if-true/fR/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _eREPLACEMENT_mbranch_mif_mtrue__fR__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST JITTER_BRANCH
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 2

  /* Define argument-access macros for !REPLACEMENT-branch-if-true/fR/retR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
    /* The 0th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* When jumping to the non-relocatable part it is important not
   to use a fallback version of JITTER_COMPUTED_GOTO, in order to
   prevent GCC from tail-merging. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
    /* Jump to non-relocatable code. */
    JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);

    /* Here the residual arity is given as zero: it's too late to
       skip residuals, since we've already jumped and this code is
       unreachable.  The instruction pointer, if any, is advanced
       in the non-relocatable code. */
    JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-branch-if-true/fR/retR, _eREPLACEMENT_mbranch_mif_mtrue__fR__retR, 0)

    /* Relocated code will jump to this label in non-relocated code. */
  JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
    JITTER_COMMENT_IN_ASM_("!REPLACEMENT-branch-if-true/fR/retR non-relocatable code");
#endif // #ifdef JITTER_REPLICATE
#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of !REPLACEMENT-branch-if-true/fR/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  no. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
//#if 0
  //fprintf (stderr, "Executing instruction %s..\n", "!REPLACEMENT-branch-if-true/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing replacement instruction %s..\n", "!REPLACEMENT-branch-if-true/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing non-relocatable instruction %s with JITTER_SPECIALIZED_INSTRUCTION_WORD_NO=%i..\n", "!REPLACEMENT-branch-if-true/fR/retR", (int) JITTER_SPECIALIZED_INSTRUCTION_WORD_NO); fflush (stderr);
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#undef JITTER_THIS_IS_A_REPLACEMENT
#define JITTER_THIS_IS_A_REPLACEMENT 1

    /* User code for !REPLACEMENT-branch-if-true/fR/retR . */
  {
/* User-specified code, user code block part: beginning. */

    jitterlisp_object top = JITTER_TOP_MAINSTACK();
    JITTER_DROP_MAINSTACK();
    JITTER_BRANCH_FAST_IF_NOTEQUAL(top, JITTERLISP_FALSE, JITTER_ARGF0);
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for !REPLACEMENT-branch-if-true/fR/retR . */

  //fprintf (stderr, "..Executed replacement instruction %s\n", "!REPLACEMENT-branch-if-true/fR/retR");
  //fprintf (stderr, "..Executed instruction %s\n", "!REPLACEMENT-branch-if-true/fR/retR");
//#endif // #if 0
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
#ifdef JITTER_REPLICATE
  {
    /* Advance the instruction pointer, if any, to skip every
       residual but the last; branch back to replicated
       code. */
    const void *_jitter_back_to_replicated_code_pointer =
      JITTER_ARGP1;
    JITTER_SKIP_RESIDUALS_;
    goto * _jitter_back_to_replicated_code_pointer;
  }
#endif // #ifdef JITTER_REPLICATE

    /* Undefine the !REPLACEMENT-branch-if-true/fR/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#ifndef JITTER_REPLICATE
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-branch-if-true/fR/retR, _eREPLACEMENT_mbranch_mif_mtrue__fR__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#endif // #ifndef JITTER_REPLICATE
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for !REPLACEMENT-branch-if-true/fR/retR, which started with its
       definitions. */
  }
#endif // #if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
/*  End of !REPLACEMENT-branch-if-true/fR/retR , a replacement specialised instruction */

  /* Ordinary specialised instruction !REPLACEMENT-call/n0/retR (replacement) */
  /* Omit this specialised instruction altogether unless
     replacements are in fact supported in this
     configuration. */
#if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
  JITTER_INSTRUCTION_PROLOG_(!REPLACEMENT-call/n0/retR, _eREPLACEMENT_mcall__n0__retR, cold)
  { /* This block begins with definitions for !REPLACEMENT-call/n0/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       234
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         !REPLACEMENT-call/n0/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "call"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "!REPLACEMENT-call/n0/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _eREPLACEMENT_mcall__n0__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement and a caller.
       Its 1-th argument, a literal, is the return address where to jump
       back after the procedure returns.  Branch-and-link
       functionality is enabled for this instruction. */
/* This instruction is non-relocatable: use branches which
   cannot ever generate defects. */
#   undef JITTER_BRANCH_AND_LINK
#   define JITTER_BRANCH_AND_LINK      _JITTER_BRANCH_AND_LINK_FALLBACK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   define JITTER_BRANCH_AND_LINK_WITH _JITTER_BRANCH_AND_LINK_WITH_FALLBACK
#   undef JITTER_BRANCH_FAST_AND_LINK
#   define JITTER_BRANCH_FAST_AND_LINK _JITTER_BRANCH_AND_LINK_FALLBACK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1

    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 0L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1


#ifdef JITTER_REPLICATE
/* When jumping to the non-relocatable part it is important not
   to use a fallback version of JITTER_COMPUTED_GOTO, in order to
   prevent GCC from tail-merging. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
    /* Jump to non-relocatable code. */
    JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);

    /* Here the residual arity is given as zero: it's too late to
       skip residuals, since we've already jumped and this code is
       unreachable.  The instruction pointer, if any, is advanced
       in the non-relocatable code. */
    JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-call/n0/retR, _eREPLACEMENT_mcall__n0__retR, 0)

    /* Relocated code will jump to this label in non-relocated code. */
  JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
    JITTER_COMMENT_IN_ASM_("!REPLACEMENT-call/n0/retR non-relocatable code");
#endif // #ifdef JITTER_REPLICATE
#if defined(JITTER_DISPATCH_NO_THREADING)             \
    && (! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)  \
        || /* is this a replacement? */ 1)
  /* We use the implicit argument at the end of the calling.
     instruction to discover the procedure return address. */
  const void * const _jitter_return_pointer
    __attribute__ ((unused)) = JITTER_ARGP1;
  /* And make it accessible to the user (who will usually call 
     JITTER_BRANCH_AND_LINK) thru a nice macro. */
# define _JITTER_RETURN_ADDRESS _jitter_return_pointer
#endif

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of !REPLACEMENT-call/n0/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  no. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
//#if 0
  //fprintf (stderr, "Executing instruction %s..\n", "!REPLACEMENT-call/n0/retR"); fflush (stderr);
  //fprintf (stderr, "Executing replacement instruction %s..\n", "!REPLACEMENT-call/n0/retR"); fflush (stderr);
  //fprintf (stderr, "Executing non-relocatable instruction %s with JITTER_SPECIALIZED_INSTRUCTION_WORD_NO=%i..\n", "!REPLACEMENT-call/n0/retR", (int) JITTER_SPECIALIZED_INSTRUCTION_WORD_NO); fflush (stderr);
  //fprintf (stderr, "Executing caller replcament: _JITTER_RETURN_ADDRESS is %p..\n", _JITTER_RETURN_ADDRESS); fflush (stderr);
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#undef JITTER_THIS_IS_A_REPLACEMENT
#define JITTER_THIS_IS_A_REPLACEMENT 1

    /* User code for !REPLACEMENT-call/n0/retR . */
  {
/* User-specified code, user code block part: beginning. */

    const jitter_uint in_arity = JITTER_ARGN0;
    jitterlisp_object callee = JITTER_AT_DEPTH_MAINSTACK(in_arity);
    struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(callee);

    if (c->kind == jitterlisp_closure_type_compiled)
      {
        /* Make place for the return address in the return stack.  The
           actual value will be written by the callee. */
        JITTER_PUSH_UNSPECIFIED_RETURNSTACK();

        /* Branch-and-link to the native code, whose first instruction
           will be a prolog. */
        struct jitterlisp_compiled_closure *cc = & c->compiled;
        JITTER_BRANCH_AND_LINK(cc->first_program_point);
      }
    else
      {
        const struct jitterlisp_interpreted_closure *ic = & c->interpreted;

        /* Push an element on the main stack.  This way we can ensure that
           every actual is accessible thru memory in a contiguous array,
           even if the main stack is TOS-optimized.  Compute the address
           (on the main stack backing) where the actuals begin.

           Notice that the interpreted function we are calling is allowed
           to call into compiled code in its turn.  This is not a problem,
           as we are not moving stack pointers down until the call ends:
           the unused part of the main and return stacks is available to
           the callee. */
        JITTER_PUSH_UNSPECIFIED_MAINSTACK();
        jitterlisp_object *actuals
          // FIXME: add a stack operator to compute this address.
          = (& JITTER_UNDER_TOP_MAINSTACK()) - in_arity + 1;

        /* Call the interpreter. */
        jitterlisp_object interpretation_result
          = jitterlisp_call_interpreted (ic, actuals, in_arity);

        /* Remove as many elements as the in-arity plus one (the callee) from
           the stack, without affecting the top.  Unless JITTER_ARGN0 is
           residual this whole loops compiles to one instruction when the main
           stack is TOS-optimized, and doesn't touch memory. */
        int i;
        for (i = 0; i < in_arity + 1; i ++)
          JITTER_NIP_MAINSTACK();

        /* Now the stack is one element higher than it was before the call,
           containing the unspecified element at the top.  Replace it with
           the result.  Again this doesn't touch memory. */
        JITTER_TOP_MAINSTACK() = interpretation_result;
      }
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for !REPLACEMENT-call/n0/retR . */

  //fprintf (stderr, "..Executed replacement instruction %s\n", "!REPLACEMENT-call/n0/retR");
  //fprintf (stderr, "..Executed instruction %s\n", "!REPLACEMENT-call/n0/retR");
//#endif // #if 0
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
#ifdef JITTER_REPLICATE
  {
    /* Advance the instruction pointer, if any, to skip every
       residual but the last; branch back to replicated
       code. */
    const void *_jitter_back_to_replicated_code_pointer =
      JITTER_ARGP1;
    JITTER_SKIP_RESIDUALS_;
    goto * _jitter_back_to_replicated_code_pointer;
  }
#endif // #ifdef JITTER_REPLICATE

    /* Undefine the !REPLACEMENT-call/n0/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#if    defined(JITTER_DISPATCH_NO_THREADING)         \
    && ! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)
# undef _JITTER_RETURN_ADDRESS
#endif

#ifndef JITTER_REPLICATE
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-call/n0/retR, _eREPLACEMENT_mcall__n0__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#endif // #ifndef JITTER_REPLICATE
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for !REPLACEMENT-call/n0/retR, which started with its
       definitions. */
  }
#endif // #if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
/*  End of !REPLACEMENT-call/n0/retR , a replacement specialised instruction */

  /* Ordinary specialised instruction !REPLACEMENT-call/n1/retR (replacement) */
  /* Omit this specialised instruction altogether unless
     replacements are in fact supported in this
     configuration. */
#if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
  JITTER_INSTRUCTION_PROLOG_(!REPLACEMENT-call/n1/retR, _eREPLACEMENT_mcall__n1__retR, cold)
  { /* This block begins with definitions for !REPLACEMENT-call/n1/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       235
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         !REPLACEMENT-call/n1/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "call"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "!REPLACEMENT-call/n1/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _eREPLACEMENT_mcall__n1__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement and a caller.
       Its 1-th argument, a literal, is the return address where to jump
       back after the procedure returns.  Branch-and-link
       functionality is enabled for this instruction. */
/* This instruction is non-relocatable: use branches which
   cannot ever generate defects. */
#   undef JITTER_BRANCH_AND_LINK
#   define JITTER_BRANCH_AND_LINK      _JITTER_BRANCH_AND_LINK_FALLBACK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   define JITTER_BRANCH_AND_LINK_WITH _JITTER_BRANCH_AND_LINK_WITH_FALLBACK
#   undef JITTER_BRANCH_FAST_AND_LINK
#   define JITTER_BRANCH_FAST_AND_LINK _JITTER_BRANCH_AND_LINK_FALLBACK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1

    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 1L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1


#ifdef JITTER_REPLICATE
/* When jumping to the non-relocatable part it is important not
   to use a fallback version of JITTER_COMPUTED_GOTO, in order to
   prevent GCC from tail-merging. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
    /* Jump to non-relocatable code. */
    JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);

    /* Here the residual arity is given as zero: it's too late to
       skip residuals, since we've already jumped and this code is
       unreachable.  The instruction pointer, if any, is advanced
       in the non-relocatable code. */
    JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-call/n1/retR, _eREPLACEMENT_mcall__n1__retR, 0)

    /* Relocated code will jump to this label in non-relocated code. */
  JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
    JITTER_COMMENT_IN_ASM_("!REPLACEMENT-call/n1/retR non-relocatable code");
#endif // #ifdef JITTER_REPLICATE
#if defined(JITTER_DISPATCH_NO_THREADING)             \
    && (! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)  \
        || /* is this a replacement? */ 1)
  /* We use the implicit argument at the end of the calling.
     instruction to discover the procedure return address. */
  const void * const _jitter_return_pointer
    __attribute__ ((unused)) = JITTER_ARGP1;
  /* And make it accessible to the user (who will usually call 
     JITTER_BRANCH_AND_LINK) thru a nice macro. */
# define _JITTER_RETURN_ADDRESS _jitter_return_pointer
#endif

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of !REPLACEMENT-call/n1/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  no. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
//#if 0
  //fprintf (stderr, "Executing instruction %s..\n", "!REPLACEMENT-call/n1/retR"); fflush (stderr);
  //fprintf (stderr, "Executing replacement instruction %s..\n", "!REPLACEMENT-call/n1/retR"); fflush (stderr);
  //fprintf (stderr, "Executing non-relocatable instruction %s with JITTER_SPECIALIZED_INSTRUCTION_WORD_NO=%i..\n", "!REPLACEMENT-call/n1/retR", (int) JITTER_SPECIALIZED_INSTRUCTION_WORD_NO); fflush (stderr);
  //fprintf (stderr, "Executing caller replcament: _JITTER_RETURN_ADDRESS is %p..\n", _JITTER_RETURN_ADDRESS); fflush (stderr);
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#undef JITTER_THIS_IS_A_REPLACEMENT
#define JITTER_THIS_IS_A_REPLACEMENT 1

    /* User code for !REPLACEMENT-call/n1/retR . */
  {
/* User-specified code, user code block part: beginning. */

    const jitter_uint in_arity = JITTER_ARGN0;
    jitterlisp_object callee = JITTER_AT_DEPTH_MAINSTACK(in_arity);
    struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(callee);

    if (c->kind == jitterlisp_closure_type_compiled)
      {
        /* Make place for the return address in the return stack.  The
           actual value will be written by the callee. */
        JITTER_PUSH_UNSPECIFIED_RETURNSTACK();

        /* Branch-and-link to the native code, whose first instruction
           will be a prolog. */
        struct jitterlisp_compiled_closure *cc = & c->compiled;
        JITTER_BRANCH_AND_LINK(cc->first_program_point);
      }
    else
      {
        const struct jitterlisp_interpreted_closure *ic = & c->interpreted;

        /* Push an element on the main stack.  This way we can ensure that
           every actual is accessible thru memory in a contiguous array,
           even if the main stack is TOS-optimized.  Compute the address
           (on the main stack backing) where the actuals begin.

           Notice that the interpreted function we are calling is allowed
           to call into compiled code in its turn.  This is not a problem,
           as we are not moving stack pointers down until the call ends:
           the unused part of the main and return stacks is available to
           the callee. */
        JITTER_PUSH_UNSPECIFIED_MAINSTACK();
        jitterlisp_object *actuals
          // FIXME: add a stack operator to compute this address.
          = (& JITTER_UNDER_TOP_MAINSTACK()) - in_arity + 1;

        /* Call the interpreter. */
        jitterlisp_object interpretation_result
          = jitterlisp_call_interpreted (ic, actuals, in_arity);

        /* Remove as many elements as the in-arity plus one (the callee) from
           the stack, without affecting the top.  Unless JITTER_ARGN0 is
           residual this whole loops compiles to one instruction when the main
           stack is TOS-optimized, and doesn't touch memory. */
        int i;
        for (i = 0; i < in_arity + 1; i ++)
          JITTER_NIP_MAINSTACK();

        /* Now the stack is one element higher than it was before the call,
           containing the unspecified element at the top.  Replace it with
           the result.  Again this doesn't touch memory. */
        JITTER_TOP_MAINSTACK() = interpretation_result;
      }
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for !REPLACEMENT-call/n1/retR . */

  //fprintf (stderr, "..Executed replacement instruction %s\n", "!REPLACEMENT-call/n1/retR");
  //fprintf (stderr, "..Executed instruction %s\n", "!REPLACEMENT-call/n1/retR");
//#endif // #if 0
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
#ifdef JITTER_REPLICATE
  {
    /* Advance the instruction pointer, if any, to skip every
       residual but the last; branch back to replicated
       code. */
    const void *_jitter_back_to_replicated_code_pointer =
      JITTER_ARGP1;
    JITTER_SKIP_RESIDUALS_;
    goto * _jitter_back_to_replicated_code_pointer;
  }
#endif // #ifdef JITTER_REPLICATE

    /* Undefine the !REPLACEMENT-call/n1/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#if    defined(JITTER_DISPATCH_NO_THREADING)         \
    && ! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)
# undef _JITTER_RETURN_ADDRESS
#endif

#ifndef JITTER_REPLICATE
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-call/n1/retR, _eREPLACEMENT_mcall__n1__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#endif // #ifndef JITTER_REPLICATE
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for !REPLACEMENT-call/n1/retR, which started with its
       definitions. */
  }
#endif // #if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
/*  End of !REPLACEMENT-call/n1/retR , a replacement specialised instruction */

  /* Ordinary specialised instruction !REPLACEMENT-call/n2/retR (replacement) */
  /* Omit this specialised instruction altogether unless
     replacements are in fact supported in this
     configuration. */
#if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
  JITTER_INSTRUCTION_PROLOG_(!REPLACEMENT-call/n2/retR, _eREPLACEMENT_mcall__n2__retR, cold)
  { /* This block begins with definitions for !REPLACEMENT-call/n2/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       236
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         !REPLACEMENT-call/n2/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "call"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "!REPLACEMENT-call/n2/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _eREPLACEMENT_mcall__n2__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement and a caller.
       Its 1-th argument, a literal, is the return address where to jump
       back after the procedure returns.  Branch-and-link
       functionality is enabled for this instruction. */
/* This instruction is non-relocatable: use branches which
   cannot ever generate defects. */
#   undef JITTER_BRANCH_AND_LINK
#   define JITTER_BRANCH_AND_LINK      _JITTER_BRANCH_AND_LINK_FALLBACK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   define JITTER_BRANCH_AND_LINK_WITH _JITTER_BRANCH_AND_LINK_WITH_FALLBACK
#   undef JITTER_BRANCH_FAST_AND_LINK
#   define JITTER_BRANCH_FAST_AND_LINK _JITTER_BRANCH_AND_LINK_FALLBACK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1

    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 2L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1


#ifdef JITTER_REPLICATE
/* When jumping to the non-relocatable part it is important not
   to use a fallback version of JITTER_COMPUTED_GOTO, in order to
   prevent GCC from tail-merging. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
    /* Jump to non-relocatable code. */
    JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);

    /* Here the residual arity is given as zero: it's too late to
       skip residuals, since we've already jumped and this code is
       unreachable.  The instruction pointer, if any, is advanced
       in the non-relocatable code. */
    JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-call/n2/retR, _eREPLACEMENT_mcall__n2__retR, 0)

    /* Relocated code will jump to this label in non-relocated code. */
  JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
    JITTER_COMMENT_IN_ASM_("!REPLACEMENT-call/n2/retR non-relocatable code");
#endif // #ifdef JITTER_REPLICATE
#if defined(JITTER_DISPATCH_NO_THREADING)             \
    && (! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)  \
        || /* is this a replacement? */ 1)
  /* We use the implicit argument at the end of the calling.
     instruction to discover the procedure return address. */
  const void * const _jitter_return_pointer
    __attribute__ ((unused)) = JITTER_ARGP1;
  /* And make it accessible to the user (who will usually call 
     JITTER_BRANCH_AND_LINK) thru a nice macro. */
# define _JITTER_RETURN_ADDRESS _jitter_return_pointer
#endif

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of !REPLACEMENT-call/n2/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  no. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
//#if 0
  //fprintf (stderr, "Executing instruction %s..\n", "!REPLACEMENT-call/n2/retR"); fflush (stderr);
  //fprintf (stderr, "Executing replacement instruction %s..\n", "!REPLACEMENT-call/n2/retR"); fflush (stderr);
  //fprintf (stderr, "Executing non-relocatable instruction %s with JITTER_SPECIALIZED_INSTRUCTION_WORD_NO=%i..\n", "!REPLACEMENT-call/n2/retR", (int) JITTER_SPECIALIZED_INSTRUCTION_WORD_NO); fflush (stderr);
  //fprintf (stderr, "Executing caller replcament: _JITTER_RETURN_ADDRESS is %p..\n", _JITTER_RETURN_ADDRESS); fflush (stderr);
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#undef JITTER_THIS_IS_A_REPLACEMENT
#define JITTER_THIS_IS_A_REPLACEMENT 1

    /* User code for !REPLACEMENT-call/n2/retR . */
  {
/* User-specified code, user code block part: beginning. */

    const jitter_uint in_arity = JITTER_ARGN0;
    jitterlisp_object callee = JITTER_AT_DEPTH_MAINSTACK(in_arity);
    struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(callee);

    if (c->kind == jitterlisp_closure_type_compiled)
      {
        /* Make place for the return address in the return stack.  The
           actual value will be written by the callee. */
        JITTER_PUSH_UNSPECIFIED_RETURNSTACK();

        /* Branch-and-link to the native code, whose first instruction
           will be a prolog. */
        struct jitterlisp_compiled_closure *cc = & c->compiled;
        JITTER_BRANCH_AND_LINK(cc->first_program_point);
      }
    else
      {
        const struct jitterlisp_interpreted_closure *ic = & c->interpreted;

        /* Push an element on the main stack.  This way we can ensure that
           every actual is accessible thru memory in a contiguous array,
           even if the main stack is TOS-optimized.  Compute the address
           (on the main stack backing) where the actuals begin.

           Notice that the interpreted function we are calling is allowed
           to call into compiled code in its turn.  This is not a problem,
           as we are not moving stack pointers down until the call ends:
           the unused part of the main and return stacks is available to
           the callee. */
        JITTER_PUSH_UNSPECIFIED_MAINSTACK();
        jitterlisp_object *actuals
          // FIXME: add a stack operator to compute this address.
          = (& JITTER_UNDER_TOP_MAINSTACK()) - in_arity + 1;

        /* Call the interpreter. */
        jitterlisp_object interpretation_result
          = jitterlisp_call_interpreted (ic, actuals, in_arity);

        /* Remove as many elements as the in-arity plus one (the callee) from
           the stack, without affecting the top.  Unless JITTER_ARGN0 is
           residual this whole loops compiles to one instruction when the main
           stack is TOS-optimized, and doesn't touch memory. */
        int i;
        for (i = 0; i < in_arity + 1; i ++)
          JITTER_NIP_MAINSTACK();

        /* Now the stack is one element higher than it was before the call,
           containing the unspecified element at the top.  Replace it with
           the result.  Again this doesn't touch memory. */
        JITTER_TOP_MAINSTACK() = interpretation_result;
      }
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for !REPLACEMENT-call/n2/retR . */

  //fprintf (stderr, "..Executed replacement instruction %s\n", "!REPLACEMENT-call/n2/retR");
  //fprintf (stderr, "..Executed instruction %s\n", "!REPLACEMENT-call/n2/retR");
//#endif // #if 0
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
#ifdef JITTER_REPLICATE
  {
    /* Advance the instruction pointer, if any, to skip every
       residual but the last; branch back to replicated
       code. */
    const void *_jitter_back_to_replicated_code_pointer =
      JITTER_ARGP1;
    JITTER_SKIP_RESIDUALS_;
    goto * _jitter_back_to_replicated_code_pointer;
  }
#endif // #ifdef JITTER_REPLICATE

    /* Undefine the !REPLACEMENT-call/n2/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#if    defined(JITTER_DISPATCH_NO_THREADING)         \
    && ! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)
# undef _JITTER_RETURN_ADDRESS
#endif

#ifndef JITTER_REPLICATE
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-call/n2/retR, _eREPLACEMENT_mcall__n2__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#endif // #ifndef JITTER_REPLICATE
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for !REPLACEMENT-call/n2/retR, which started with its
       definitions. */
  }
#endif // #if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
/*  End of !REPLACEMENT-call/n2/retR , a replacement specialised instruction */

  /* Ordinary specialised instruction !REPLACEMENT-call/n3/retR (replacement) */
  /* Omit this specialised instruction altogether unless
     replacements are in fact supported in this
     configuration. */
#if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
  JITTER_INSTRUCTION_PROLOG_(!REPLACEMENT-call/n3/retR, _eREPLACEMENT_mcall__n3__retR, cold)
  { /* This block begins with definitions for !REPLACEMENT-call/n3/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       237
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         !REPLACEMENT-call/n3/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "call"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "!REPLACEMENT-call/n3/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _eREPLACEMENT_mcall__n3__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement and a caller.
       Its 1-th argument, a literal, is the return address where to jump
       back after the procedure returns.  Branch-and-link
       functionality is enabled for this instruction. */
/* This instruction is non-relocatable: use branches which
   cannot ever generate defects. */
#   undef JITTER_BRANCH_AND_LINK
#   define JITTER_BRANCH_AND_LINK      _JITTER_BRANCH_AND_LINK_FALLBACK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   define JITTER_BRANCH_AND_LINK_WITH _JITTER_BRANCH_AND_LINK_WITH_FALLBACK
#   undef JITTER_BRANCH_FAST_AND_LINK
#   define JITTER_BRANCH_FAST_AND_LINK _JITTER_BRANCH_AND_LINK_FALLBACK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1

    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 3L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1


#ifdef JITTER_REPLICATE
/* When jumping to the non-relocatable part it is important not
   to use a fallback version of JITTER_COMPUTED_GOTO, in order to
   prevent GCC from tail-merging. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
    /* Jump to non-relocatable code. */
    JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);

    /* Here the residual arity is given as zero: it's too late to
       skip residuals, since we've already jumped and this code is
       unreachable.  The instruction pointer, if any, is advanced
       in the non-relocatable code. */
    JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-call/n3/retR, _eREPLACEMENT_mcall__n3__retR, 0)

    /* Relocated code will jump to this label in non-relocated code. */
  JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
    JITTER_COMMENT_IN_ASM_("!REPLACEMENT-call/n3/retR non-relocatable code");
#endif // #ifdef JITTER_REPLICATE
#if defined(JITTER_DISPATCH_NO_THREADING)             \
    && (! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)  \
        || /* is this a replacement? */ 1)
  /* We use the implicit argument at the end of the calling.
     instruction to discover the procedure return address. */
  const void * const _jitter_return_pointer
    __attribute__ ((unused)) = JITTER_ARGP1;
  /* And make it accessible to the user (who will usually call 
     JITTER_BRANCH_AND_LINK) thru a nice macro. */
# define _JITTER_RETURN_ADDRESS _jitter_return_pointer
#endif

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of !REPLACEMENT-call/n3/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  no. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
//#if 0
  //fprintf (stderr, "Executing instruction %s..\n", "!REPLACEMENT-call/n3/retR"); fflush (stderr);
  //fprintf (stderr, "Executing replacement instruction %s..\n", "!REPLACEMENT-call/n3/retR"); fflush (stderr);
  //fprintf (stderr, "Executing non-relocatable instruction %s with JITTER_SPECIALIZED_INSTRUCTION_WORD_NO=%i..\n", "!REPLACEMENT-call/n3/retR", (int) JITTER_SPECIALIZED_INSTRUCTION_WORD_NO); fflush (stderr);
  //fprintf (stderr, "Executing caller replcament: _JITTER_RETURN_ADDRESS is %p..\n", _JITTER_RETURN_ADDRESS); fflush (stderr);
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#undef JITTER_THIS_IS_A_REPLACEMENT
#define JITTER_THIS_IS_A_REPLACEMENT 1

    /* User code for !REPLACEMENT-call/n3/retR . */
  {
/* User-specified code, user code block part: beginning. */

    const jitter_uint in_arity = JITTER_ARGN0;
    jitterlisp_object callee = JITTER_AT_DEPTH_MAINSTACK(in_arity);
    struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(callee);

    if (c->kind == jitterlisp_closure_type_compiled)
      {
        /* Make place for the return address in the return stack.  The
           actual value will be written by the callee. */
        JITTER_PUSH_UNSPECIFIED_RETURNSTACK();

        /* Branch-and-link to the native code, whose first instruction
           will be a prolog. */
        struct jitterlisp_compiled_closure *cc = & c->compiled;
        JITTER_BRANCH_AND_LINK(cc->first_program_point);
      }
    else
      {
        const struct jitterlisp_interpreted_closure *ic = & c->interpreted;

        /* Push an element on the main stack.  This way we can ensure that
           every actual is accessible thru memory in a contiguous array,
           even if the main stack is TOS-optimized.  Compute the address
           (on the main stack backing) where the actuals begin.

           Notice that the interpreted function we are calling is allowed
           to call into compiled code in its turn.  This is not a problem,
           as we are not moving stack pointers down until the call ends:
           the unused part of the main and return stacks is available to
           the callee. */
        JITTER_PUSH_UNSPECIFIED_MAINSTACK();
        jitterlisp_object *actuals
          // FIXME: add a stack operator to compute this address.
          = (& JITTER_UNDER_TOP_MAINSTACK()) - in_arity + 1;

        /* Call the interpreter. */
        jitterlisp_object interpretation_result
          = jitterlisp_call_interpreted (ic, actuals, in_arity);

        /* Remove as many elements as the in-arity plus one (the callee) from
           the stack, without affecting the top.  Unless JITTER_ARGN0 is
           residual this whole loops compiles to one instruction when the main
           stack is TOS-optimized, and doesn't touch memory. */
        int i;
        for (i = 0; i < in_arity + 1; i ++)
          JITTER_NIP_MAINSTACK();

        /* Now the stack is one element higher than it was before the call,
           containing the unspecified element at the top.  Replace it with
           the result.  Again this doesn't touch memory. */
        JITTER_TOP_MAINSTACK() = interpretation_result;
      }
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for !REPLACEMENT-call/n3/retR . */

  //fprintf (stderr, "..Executed replacement instruction %s\n", "!REPLACEMENT-call/n3/retR");
  //fprintf (stderr, "..Executed instruction %s\n", "!REPLACEMENT-call/n3/retR");
//#endif // #if 0
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
#ifdef JITTER_REPLICATE
  {
    /* Advance the instruction pointer, if any, to skip every
       residual but the last; branch back to replicated
       code. */
    const void *_jitter_back_to_replicated_code_pointer =
      JITTER_ARGP1;
    JITTER_SKIP_RESIDUALS_;
    goto * _jitter_back_to_replicated_code_pointer;
  }
#endif // #ifdef JITTER_REPLICATE

    /* Undefine the !REPLACEMENT-call/n3/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#if    defined(JITTER_DISPATCH_NO_THREADING)         \
    && ! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)
# undef _JITTER_RETURN_ADDRESS
#endif

#ifndef JITTER_REPLICATE
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-call/n3/retR, _eREPLACEMENT_mcall__n3__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#endif // #ifndef JITTER_REPLICATE
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for !REPLACEMENT-call/n3/retR, which started with its
       definitions. */
  }
#endif // #if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
/*  End of !REPLACEMENT-call/n3/retR , a replacement specialised instruction */

  /* Ordinary specialised instruction !REPLACEMENT-call/n4/retR (replacement) */
  /* Omit this specialised instruction altogether unless
     replacements are in fact supported in this
     configuration. */
#if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
  JITTER_INSTRUCTION_PROLOG_(!REPLACEMENT-call/n4/retR, _eREPLACEMENT_mcall__n4__retR, cold)
  { /* This block begins with definitions for !REPLACEMENT-call/n4/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       238
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         !REPLACEMENT-call/n4/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "call"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "!REPLACEMENT-call/n4/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _eREPLACEMENT_mcall__n4__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement and a caller.
       Its 1-th argument, a literal, is the return address where to jump
       back after the procedure returns.  Branch-and-link
       functionality is enabled for this instruction. */
/* This instruction is non-relocatable: use branches which
   cannot ever generate defects. */
#   undef JITTER_BRANCH_AND_LINK
#   define JITTER_BRANCH_AND_LINK      _JITTER_BRANCH_AND_LINK_FALLBACK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   define JITTER_BRANCH_AND_LINK_WITH _JITTER_BRANCH_AND_LINK_WITH_FALLBACK
#   undef JITTER_BRANCH_FAST_AND_LINK
#   define JITTER_BRANCH_FAST_AND_LINK _JITTER_BRANCH_AND_LINK_FALLBACK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1

    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 4L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1


#ifdef JITTER_REPLICATE
/* When jumping to the non-relocatable part it is important not
   to use a fallback version of JITTER_COMPUTED_GOTO, in order to
   prevent GCC from tail-merging. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
    /* Jump to non-relocatable code. */
    JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);

    /* Here the residual arity is given as zero: it's too late to
       skip residuals, since we've already jumped and this code is
       unreachable.  The instruction pointer, if any, is advanced
       in the non-relocatable code. */
    JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-call/n4/retR, _eREPLACEMENT_mcall__n4__retR, 0)

    /* Relocated code will jump to this label in non-relocated code. */
  JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
    JITTER_COMMENT_IN_ASM_("!REPLACEMENT-call/n4/retR non-relocatable code");
#endif // #ifdef JITTER_REPLICATE
#if defined(JITTER_DISPATCH_NO_THREADING)             \
    && (! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)  \
        || /* is this a replacement? */ 1)
  /* We use the implicit argument at the end of the calling.
     instruction to discover the procedure return address. */
  const void * const _jitter_return_pointer
    __attribute__ ((unused)) = JITTER_ARGP1;
  /* And make it accessible to the user (who will usually call 
     JITTER_BRANCH_AND_LINK) thru a nice macro. */
# define _JITTER_RETURN_ADDRESS _jitter_return_pointer
#endif

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of !REPLACEMENT-call/n4/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  no. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
//#if 0
  //fprintf (stderr, "Executing instruction %s..\n", "!REPLACEMENT-call/n4/retR"); fflush (stderr);
  //fprintf (stderr, "Executing replacement instruction %s..\n", "!REPLACEMENT-call/n4/retR"); fflush (stderr);
  //fprintf (stderr, "Executing non-relocatable instruction %s with JITTER_SPECIALIZED_INSTRUCTION_WORD_NO=%i..\n", "!REPLACEMENT-call/n4/retR", (int) JITTER_SPECIALIZED_INSTRUCTION_WORD_NO); fflush (stderr);
  //fprintf (stderr, "Executing caller replcament: _JITTER_RETURN_ADDRESS is %p..\n", _JITTER_RETURN_ADDRESS); fflush (stderr);
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#undef JITTER_THIS_IS_A_REPLACEMENT
#define JITTER_THIS_IS_A_REPLACEMENT 1

    /* User code for !REPLACEMENT-call/n4/retR . */
  {
/* User-specified code, user code block part: beginning. */

    const jitter_uint in_arity = JITTER_ARGN0;
    jitterlisp_object callee = JITTER_AT_DEPTH_MAINSTACK(in_arity);
    struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(callee);

    if (c->kind == jitterlisp_closure_type_compiled)
      {
        /* Make place for the return address in the return stack.  The
           actual value will be written by the callee. */
        JITTER_PUSH_UNSPECIFIED_RETURNSTACK();

        /* Branch-and-link to the native code, whose first instruction
           will be a prolog. */
        struct jitterlisp_compiled_closure *cc = & c->compiled;
        JITTER_BRANCH_AND_LINK(cc->first_program_point);
      }
    else
      {
        const struct jitterlisp_interpreted_closure *ic = & c->interpreted;

        /* Push an element on the main stack.  This way we can ensure that
           every actual is accessible thru memory in a contiguous array,
           even if the main stack is TOS-optimized.  Compute the address
           (on the main stack backing) where the actuals begin.

           Notice that the interpreted function we are calling is allowed
           to call into compiled code in its turn.  This is not a problem,
           as we are not moving stack pointers down until the call ends:
           the unused part of the main and return stacks is available to
           the callee. */
        JITTER_PUSH_UNSPECIFIED_MAINSTACK();
        jitterlisp_object *actuals
          // FIXME: add a stack operator to compute this address.
          = (& JITTER_UNDER_TOP_MAINSTACK()) - in_arity + 1;

        /* Call the interpreter. */
        jitterlisp_object interpretation_result
          = jitterlisp_call_interpreted (ic, actuals, in_arity);

        /* Remove as many elements as the in-arity plus one (the callee) from
           the stack, without affecting the top.  Unless JITTER_ARGN0 is
           residual this whole loops compiles to one instruction when the main
           stack is TOS-optimized, and doesn't touch memory. */
        int i;
        for (i = 0; i < in_arity + 1; i ++)
          JITTER_NIP_MAINSTACK();

        /* Now the stack is one element higher than it was before the call,
           containing the unspecified element at the top.  Replace it with
           the result.  Again this doesn't touch memory. */
        JITTER_TOP_MAINSTACK() = interpretation_result;
      }
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for !REPLACEMENT-call/n4/retR . */

  //fprintf (stderr, "..Executed replacement instruction %s\n", "!REPLACEMENT-call/n4/retR");
  //fprintf (stderr, "..Executed instruction %s\n", "!REPLACEMENT-call/n4/retR");
//#endif // #if 0
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
#ifdef JITTER_REPLICATE
  {
    /* Advance the instruction pointer, if any, to skip every
       residual but the last; branch back to replicated
       code. */
    const void *_jitter_back_to_replicated_code_pointer =
      JITTER_ARGP1;
    JITTER_SKIP_RESIDUALS_;
    goto * _jitter_back_to_replicated_code_pointer;
  }
#endif // #ifdef JITTER_REPLICATE

    /* Undefine the !REPLACEMENT-call/n4/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#if    defined(JITTER_DISPATCH_NO_THREADING)         \
    && ! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)
# undef _JITTER_RETURN_ADDRESS
#endif

#ifndef JITTER_REPLICATE
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-call/n4/retR, _eREPLACEMENT_mcall__n4__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#endif // #ifndef JITTER_REPLICATE
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for !REPLACEMENT-call/n4/retR, which started with its
       definitions. */
  }
#endif // #if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
/*  End of !REPLACEMENT-call/n4/retR , a replacement specialised instruction */

  /* Ordinary specialised instruction !REPLACEMENT-call/n5/retR (replacement) */
  /* Omit this specialised instruction altogether unless
     replacements are in fact supported in this
     configuration. */
#if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
  JITTER_INSTRUCTION_PROLOG_(!REPLACEMENT-call/n5/retR, _eREPLACEMENT_mcall__n5__retR, cold)
  { /* This block begins with definitions for !REPLACEMENT-call/n5/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       239
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         !REPLACEMENT-call/n5/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "call"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "!REPLACEMENT-call/n5/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _eREPLACEMENT_mcall__n5__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement and a caller.
       Its 1-th argument, a literal, is the return address where to jump
       back after the procedure returns.  Branch-and-link
       functionality is enabled for this instruction. */
/* This instruction is non-relocatable: use branches which
   cannot ever generate defects. */
#   undef JITTER_BRANCH_AND_LINK
#   define JITTER_BRANCH_AND_LINK      _JITTER_BRANCH_AND_LINK_FALLBACK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   define JITTER_BRANCH_AND_LINK_WITH _JITTER_BRANCH_AND_LINK_WITH_FALLBACK
#   undef JITTER_BRANCH_FAST_AND_LINK
#   define JITTER_BRANCH_FAST_AND_LINK _JITTER_BRANCH_AND_LINK_FALLBACK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1

    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 5L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1


#ifdef JITTER_REPLICATE
/* When jumping to the non-relocatable part it is important not
   to use a fallback version of JITTER_COMPUTED_GOTO, in order to
   prevent GCC from tail-merging. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
    /* Jump to non-relocatable code. */
    JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);

    /* Here the residual arity is given as zero: it's too late to
       skip residuals, since we've already jumped and this code is
       unreachable.  The instruction pointer, if any, is advanced
       in the non-relocatable code. */
    JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-call/n5/retR, _eREPLACEMENT_mcall__n5__retR, 0)

    /* Relocated code will jump to this label in non-relocated code. */
  JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
    JITTER_COMMENT_IN_ASM_("!REPLACEMENT-call/n5/retR non-relocatable code");
#endif // #ifdef JITTER_REPLICATE
#if defined(JITTER_DISPATCH_NO_THREADING)             \
    && (! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)  \
        || /* is this a replacement? */ 1)
  /* We use the implicit argument at the end of the calling.
     instruction to discover the procedure return address. */
  const void * const _jitter_return_pointer
    __attribute__ ((unused)) = JITTER_ARGP1;
  /* And make it accessible to the user (who will usually call 
     JITTER_BRANCH_AND_LINK) thru a nice macro. */
# define _JITTER_RETURN_ADDRESS _jitter_return_pointer
#endif

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of !REPLACEMENT-call/n5/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  no. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
//#if 0
  //fprintf (stderr, "Executing instruction %s..\n", "!REPLACEMENT-call/n5/retR"); fflush (stderr);
  //fprintf (stderr, "Executing replacement instruction %s..\n", "!REPLACEMENT-call/n5/retR"); fflush (stderr);
  //fprintf (stderr, "Executing non-relocatable instruction %s with JITTER_SPECIALIZED_INSTRUCTION_WORD_NO=%i..\n", "!REPLACEMENT-call/n5/retR", (int) JITTER_SPECIALIZED_INSTRUCTION_WORD_NO); fflush (stderr);
  //fprintf (stderr, "Executing caller replcament: _JITTER_RETURN_ADDRESS is %p..\n", _JITTER_RETURN_ADDRESS); fflush (stderr);
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#undef JITTER_THIS_IS_A_REPLACEMENT
#define JITTER_THIS_IS_A_REPLACEMENT 1

    /* User code for !REPLACEMENT-call/n5/retR . */
  {
/* User-specified code, user code block part: beginning. */

    const jitter_uint in_arity = JITTER_ARGN0;
    jitterlisp_object callee = JITTER_AT_DEPTH_MAINSTACK(in_arity);
    struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(callee);

    if (c->kind == jitterlisp_closure_type_compiled)
      {
        /* Make place for the return address in the return stack.  The
           actual value will be written by the callee. */
        JITTER_PUSH_UNSPECIFIED_RETURNSTACK();

        /* Branch-and-link to the native code, whose first instruction
           will be a prolog. */
        struct jitterlisp_compiled_closure *cc = & c->compiled;
        JITTER_BRANCH_AND_LINK(cc->first_program_point);
      }
    else
      {
        const struct jitterlisp_interpreted_closure *ic = & c->interpreted;

        /* Push an element on the main stack.  This way we can ensure that
           every actual is accessible thru memory in a contiguous array,
           even if the main stack is TOS-optimized.  Compute the address
           (on the main stack backing) where the actuals begin.

           Notice that the interpreted function we are calling is allowed
           to call into compiled code in its turn.  This is not a problem,
           as we are not moving stack pointers down until the call ends:
           the unused part of the main and return stacks is available to
           the callee. */
        JITTER_PUSH_UNSPECIFIED_MAINSTACK();
        jitterlisp_object *actuals
          // FIXME: add a stack operator to compute this address.
          = (& JITTER_UNDER_TOP_MAINSTACK()) - in_arity + 1;

        /* Call the interpreter. */
        jitterlisp_object interpretation_result
          = jitterlisp_call_interpreted (ic, actuals, in_arity);

        /* Remove as many elements as the in-arity plus one (the callee) from
           the stack, without affecting the top.  Unless JITTER_ARGN0 is
           residual this whole loops compiles to one instruction when the main
           stack is TOS-optimized, and doesn't touch memory. */
        int i;
        for (i = 0; i < in_arity + 1; i ++)
          JITTER_NIP_MAINSTACK();

        /* Now the stack is one element higher than it was before the call,
           containing the unspecified element at the top.  Replace it with
           the result.  Again this doesn't touch memory. */
        JITTER_TOP_MAINSTACK() = interpretation_result;
      }
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for !REPLACEMENT-call/n5/retR . */

  //fprintf (stderr, "..Executed replacement instruction %s\n", "!REPLACEMENT-call/n5/retR");
  //fprintf (stderr, "..Executed instruction %s\n", "!REPLACEMENT-call/n5/retR");
//#endif // #if 0
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
#ifdef JITTER_REPLICATE
  {
    /* Advance the instruction pointer, if any, to skip every
       residual but the last; branch back to replicated
       code. */
    const void *_jitter_back_to_replicated_code_pointer =
      JITTER_ARGP1;
    JITTER_SKIP_RESIDUALS_;
    goto * _jitter_back_to_replicated_code_pointer;
  }
#endif // #ifdef JITTER_REPLICATE

    /* Undefine the !REPLACEMENT-call/n5/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#if    defined(JITTER_DISPATCH_NO_THREADING)         \
    && ! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)
# undef _JITTER_RETURN_ADDRESS
#endif

#ifndef JITTER_REPLICATE
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-call/n5/retR, _eREPLACEMENT_mcall__n5__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#endif // #ifndef JITTER_REPLICATE
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for !REPLACEMENT-call/n5/retR, which started with its
       definitions. */
  }
#endif // #if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
/*  End of !REPLACEMENT-call/n5/retR , a replacement specialised instruction */

  /* Ordinary specialised instruction !REPLACEMENT-call/n6/retR (replacement) */
  /* Omit this specialised instruction altogether unless
     replacements are in fact supported in this
     configuration. */
#if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
  JITTER_INSTRUCTION_PROLOG_(!REPLACEMENT-call/n6/retR, _eREPLACEMENT_mcall__n6__retR, cold)
  { /* This block begins with definitions for !REPLACEMENT-call/n6/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       240
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         !REPLACEMENT-call/n6/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "call"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "!REPLACEMENT-call/n6/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _eREPLACEMENT_mcall__n6__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement and a caller.
       Its 1-th argument, a literal, is the return address where to jump
       back after the procedure returns.  Branch-and-link
       functionality is enabled for this instruction. */
/* This instruction is non-relocatable: use branches which
   cannot ever generate defects. */
#   undef JITTER_BRANCH_AND_LINK
#   define JITTER_BRANCH_AND_LINK      _JITTER_BRANCH_AND_LINK_FALLBACK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   define JITTER_BRANCH_AND_LINK_WITH _JITTER_BRANCH_AND_LINK_WITH_FALLBACK
#   undef JITTER_BRANCH_FAST_AND_LINK
#   define JITTER_BRANCH_FAST_AND_LINK _JITTER_BRANCH_AND_LINK_FALLBACK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1

    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 6L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1


#ifdef JITTER_REPLICATE
/* When jumping to the non-relocatable part it is important not
   to use a fallback version of JITTER_COMPUTED_GOTO, in order to
   prevent GCC from tail-merging. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
    /* Jump to non-relocatable code. */
    JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);

    /* Here the residual arity is given as zero: it's too late to
       skip residuals, since we've already jumped and this code is
       unreachable.  The instruction pointer, if any, is advanced
       in the non-relocatable code. */
    JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-call/n6/retR, _eREPLACEMENT_mcall__n6__retR, 0)

    /* Relocated code will jump to this label in non-relocated code. */
  JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
    JITTER_COMMENT_IN_ASM_("!REPLACEMENT-call/n6/retR non-relocatable code");
#endif // #ifdef JITTER_REPLICATE
#if defined(JITTER_DISPATCH_NO_THREADING)             \
    && (! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)  \
        || /* is this a replacement? */ 1)
  /* We use the implicit argument at the end of the calling.
     instruction to discover the procedure return address. */
  const void * const _jitter_return_pointer
    __attribute__ ((unused)) = JITTER_ARGP1;
  /* And make it accessible to the user (who will usually call 
     JITTER_BRANCH_AND_LINK) thru a nice macro. */
# define _JITTER_RETURN_ADDRESS _jitter_return_pointer
#endif

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of !REPLACEMENT-call/n6/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  no. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
//#if 0
  //fprintf (stderr, "Executing instruction %s..\n", "!REPLACEMENT-call/n6/retR"); fflush (stderr);
  //fprintf (stderr, "Executing replacement instruction %s..\n", "!REPLACEMENT-call/n6/retR"); fflush (stderr);
  //fprintf (stderr, "Executing non-relocatable instruction %s with JITTER_SPECIALIZED_INSTRUCTION_WORD_NO=%i..\n", "!REPLACEMENT-call/n6/retR", (int) JITTER_SPECIALIZED_INSTRUCTION_WORD_NO); fflush (stderr);
  //fprintf (stderr, "Executing caller replcament: _JITTER_RETURN_ADDRESS is %p..\n", _JITTER_RETURN_ADDRESS); fflush (stderr);
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#undef JITTER_THIS_IS_A_REPLACEMENT
#define JITTER_THIS_IS_A_REPLACEMENT 1

    /* User code for !REPLACEMENT-call/n6/retR . */
  {
/* User-specified code, user code block part: beginning. */

    const jitter_uint in_arity = JITTER_ARGN0;
    jitterlisp_object callee = JITTER_AT_DEPTH_MAINSTACK(in_arity);
    struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(callee);

    if (c->kind == jitterlisp_closure_type_compiled)
      {
        /* Make place for the return address in the return stack.  The
           actual value will be written by the callee. */
        JITTER_PUSH_UNSPECIFIED_RETURNSTACK();

        /* Branch-and-link to the native code, whose first instruction
           will be a prolog. */
        struct jitterlisp_compiled_closure *cc = & c->compiled;
        JITTER_BRANCH_AND_LINK(cc->first_program_point);
      }
    else
      {
        const struct jitterlisp_interpreted_closure *ic = & c->interpreted;

        /* Push an element on the main stack.  This way we can ensure that
           every actual is accessible thru memory in a contiguous array,
           even if the main stack is TOS-optimized.  Compute the address
           (on the main stack backing) where the actuals begin.

           Notice that the interpreted function we are calling is allowed
           to call into compiled code in its turn.  This is not a problem,
           as we are not moving stack pointers down until the call ends:
           the unused part of the main and return stacks is available to
           the callee. */
        JITTER_PUSH_UNSPECIFIED_MAINSTACK();
        jitterlisp_object *actuals
          // FIXME: add a stack operator to compute this address.
          = (& JITTER_UNDER_TOP_MAINSTACK()) - in_arity + 1;

        /* Call the interpreter. */
        jitterlisp_object interpretation_result
          = jitterlisp_call_interpreted (ic, actuals, in_arity);

        /* Remove as many elements as the in-arity plus one (the callee) from
           the stack, without affecting the top.  Unless JITTER_ARGN0 is
           residual this whole loops compiles to one instruction when the main
           stack is TOS-optimized, and doesn't touch memory. */
        int i;
        for (i = 0; i < in_arity + 1; i ++)
          JITTER_NIP_MAINSTACK();

        /* Now the stack is one element higher than it was before the call,
           containing the unspecified element at the top.  Replace it with
           the result.  Again this doesn't touch memory. */
        JITTER_TOP_MAINSTACK() = interpretation_result;
      }
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for !REPLACEMENT-call/n6/retR . */

  //fprintf (stderr, "..Executed replacement instruction %s\n", "!REPLACEMENT-call/n6/retR");
  //fprintf (stderr, "..Executed instruction %s\n", "!REPLACEMENT-call/n6/retR");
//#endif // #if 0
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
#ifdef JITTER_REPLICATE
  {
    /* Advance the instruction pointer, if any, to skip every
       residual but the last; branch back to replicated
       code. */
    const void *_jitter_back_to_replicated_code_pointer =
      JITTER_ARGP1;
    JITTER_SKIP_RESIDUALS_;
    goto * _jitter_back_to_replicated_code_pointer;
  }
#endif // #ifdef JITTER_REPLICATE

    /* Undefine the !REPLACEMENT-call/n6/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#if    defined(JITTER_DISPATCH_NO_THREADING)         \
    && ! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)
# undef _JITTER_RETURN_ADDRESS
#endif

#ifndef JITTER_REPLICATE
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-call/n6/retR, _eREPLACEMENT_mcall__n6__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#endif // #ifndef JITTER_REPLICATE
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for !REPLACEMENT-call/n6/retR, which started with its
       definitions. */
  }
#endif // #if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
/*  End of !REPLACEMENT-call/n6/retR , a replacement specialised instruction */

  /* Ordinary specialised instruction !REPLACEMENT-call/n7/retR (replacement) */
  /* Omit this specialised instruction altogether unless
     replacements are in fact supported in this
     configuration. */
#if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
  JITTER_INSTRUCTION_PROLOG_(!REPLACEMENT-call/n7/retR, _eREPLACEMENT_mcall__n7__retR, cold)
  { /* This block begins with definitions for !REPLACEMENT-call/n7/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       241
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         !REPLACEMENT-call/n7/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "call"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "!REPLACEMENT-call/n7/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _eREPLACEMENT_mcall__n7__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement and a caller.
       Its 1-th argument, a literal, is the return address where to jump
       back after the procedure returns.  Branch-and-link
       functionality is enabled for this instruction. */
/* This instruction is non-relocatable: use branches which
   cannot ever generate defects. */
#   undef JITTER_BRANCH_AND_LINK
#   define JITTER_BRANCH_AND_LINK      _JITTER_BRANCH_AND_LINK_FALLBACK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   define JITTER_BRANCH_AND_LINK_WITH _JITTER_BRANCH_AND_LINK_WITH_FALLBACK
#   undef JITTER_BRANCH_FAST_AND_LINK
#   define JITTER_BRANCH_FAST_AND_LINK _JITTER_BRANCH_AND_LINK_FALLBACK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1

    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 7L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1


#ifdef JITTER_REPLICATE
/* When jumping to the non-relocatable part it is important not
   to use a fallback version of JITTER_COMPUTED_GOTO, in order to
   prevent GCC from tail-merging. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
    /* Jump to non-relocatable code. */
    JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);

    /* Here the residual arity is given as zero: it's too late to
       skip residuals, since we've already jumped and this code is
       unreachable.  The instruction pointer, if any, is advanced
       in the non-relocatable code. */
    JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-call/n7/retR, _eREPLACEMENT_mcall__n7__retR, 0)

    /* Relocated code will jump to this label in non-relocated code. */
  JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
    JITTER_COMMENT_IN_ASM_("!REPLACEMENT-call/n7/retR non-relocatable code");
#endif // #ifdef JITTER_REPLICATE
#if defined(JITTER_DISPATCH_NO_THREADING)             \
    && (! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)  \
        || /* is this a replacement? */ 1)
  /* We use the implicit argument at the end of the calling.
     instruction to discover the procedure return address. */
  const void * const _jitter_return_pointer
    __attribute__ ((unused)) = JITTER_ARGP1;
  /* And make it accessible to the user (who will usually call 
     JITTER_BRANCH_AND_LINK) thru a nice macro. */
# define _JITTER_RETURN_ADDRESS _jitter_return_pointer
#endif

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of !REPLACEMENT-call/n7/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  no. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
//#if 0
  //fprintf (stderr, "Executing instruction %s..\n", "!REPLACEMENT-call/n7/retR"); fflush (stderr);
  //fprintf (stderr, "Executing replacement instruction %s..\n", "!REPLACEMENT-call/n7/retR"); fflush (stderr);
  //fprintf (stderr, "Executing non-relocatable instruction %s with JITTER_SPECIALIZED_INSTRUCTION_WORD_NO=%i..\n", "!REPLACEMENT-call/n7/retR", (int) JITTER_SPECIALIZED_INSTRUCTION_WORD_NO); fflush (stderr);
  //fprintf (stderr, "Executing caller replcament: _JITTER_RETURN_ADDRESS is %p..\n", _JITTER_RETURN_ADDRESS); fflush (stderr);
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#undef JITTER_THIS_IS_A_REPLACEMENT
#define JITTER_THIS_IS_A_REPLACEMENT 1

    /* User code for !REPLACEMENT-call/n7/retR . */
  {
/* User-specified code, user code block part: beginning. */

    const jitter_uint in_arity = JITTER_ARGN0;
    jitterlisp_object callee = JITTER_AT_DEPTH_MAINSTACK(in_arity);
    struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(callee);

    if (c->kind == jitterlisp_closure_type_compiled)
      {
        /* Make place for the return address in the return stack.  The
           actual value will be written by the callee. */
        JITTER_PUSH_UNSPECIFIED_RETURNSTACK();

        /* Branch-and-link to the native code, whose first instruction
           will be a prolog. */
        struct jitterlisp_compiled_closure *cc = & c->compiled;
        JITTER_BRANCH_AND_LINK(cc->first_program_point);
      }
    else
      {
        const struct jitterlisp_interpreted_closure *ic = & c->interpreted;

        /* Push an element on the main stack.  This way we can ensure that
           every actual is accessible thru memory in a contiguous array,
           even if the main stack is TOS-optimized.  Compute the address
           (on the main stack backing) where the actuals begin.

           Notice that the interpreted function we are calling is allowed
           to call into compiled code in its turn.  This is not a problem,
           as we are not moving stack pointers down until the call ends:
           the unused part of the main and return stacks is available to
           the callee. */
        JITTER_PUSH_UNSPECIFIED_MAINSTACK();
        jitterlisp_object *actuals
          // FIXME: add a stack operator to compute this address.
          = (& JITTER_UNDER_TOP_MAINSTACK()) - in_arity + 1;

        /* Call the interpreter. */
        jitterlisp_object interpretation_result
          = jitterlisp_call_interpreted (ic, actuals, in_arity);

        /* Remove as many elements as the in-arity plus one (the callee) from
           the stack, without affecting the top.  Unless JITTER_ARGN0 is
           residual this whole loops compiles to one instruction when the main
           stack is TOS-optimized, and doesn't touch memory. */
        int i;
        for (i = 0; i < in_arity + 1; i ++)
          JITTER_NIP_MAINSTACK();

        /* Now the stack is one element higher than it was before the call,
           containing the unspecified element at the top.  Replace it with
           the result.  Again this doesn't touch memory. */
        JITTER_TOP_MAINSTACK() = interpretation_result;
      }
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for !REPLACEMENT-call/n7/retR . */

  //fprintf (stderr, "..Executed replacement instruction %s\n", "!REPLACEMENT-call/n7/retR");
  //fprintf (stderr, "..Executed instruction %s\n", "!REPLACEMENT-call/n7/retR");
//#endif // #if 0
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
#ifdef JITTER_REPLICATE
  {
    /* Advance the instruction pointer, if any, to skip every
       residual but the last; branch back to replicated
       code. */
    const void *_jitter_back_to_replicated_code_pointer =
      JITTER_ARGP1;
    JITTER_SKIP_RESIDUALS_;
    goto * _jitter_back_to_replicated_code_pointer;
  }
#endif // #ifdef JITTER_REPLICATE

    /* Undefine the !REPLACEMENT-call/n7/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#if    defined(JITTER_DISPATCH_NO_THREADING)         \
    && ! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)
# undef _JITTER_RETURN_ADDRESS
#endif

#ifndef JITTER_REPLICATE
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-call/n7/retR, _eREPLACEMENT_mcall__n7__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#endif // #ifndef JITTER_REPLICATE
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for !REPLACEMENT-call/n7/retR, which started with its
       definitions. */
  }
#endif // #if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
/*  End of !REPLACEMENT-call/n7/retR , a replacement specialised instruction */

  /* Ordinary specialised instruction !REPLACEMENT-call/n8/retR (replacement) */
  /* Omit this specialised instruction altogether unless
     replacements are in fact supported in this
     configuration. */
#if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
  JITTER_INSTRUCTION_PROLOG_(!REPLACEMENT-call/n8/retR, _eREPLACEMENT_mcall__n8__retR, cold)
  { /* This block begins with definitions for !REPLACEMENT-call/n8/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       242
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         !REPLACEMENT-call/n8/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "call"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "!REPLACEMENT-call/n8/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _eREPLACEMENT_mcall__n8__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement and a caller.
       Its 1-th argument, a literal, is the return address where to jump
       back after the procedure returns.  Branch-and-link
       functionality is enabled for this instruction. */
/* This instruction is non-relocatable: use branches which
   cannot ever generate defects. */
#   undef JITTER_BRANCH_AND_LINK
#   define JITTER_BRANCH_AND_LINK      _JITTER_BRANCH_AND_LINK_FALLBACK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   define JITTER_BRANCH_AND_LINK_WITH _JITTER_BRANCH_AND_LINK_WITH_FALLBACK
#   undef JITTER_BRANCH_FAST_AND_LINK
#   define JITTER_BRANCH_FAST_AND_LINK _JITTER_BRANCH_AND_LINK_FALLBACK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1

    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 8L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1


#ifdef JITTER_REPLICATE
/* When jumping to the non-relocatable part it is important not
   to use a fallback version of JITTER_COMPUTED_GOTO, in order to
   prevent GCC from tail-merging. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
    /* Jump to non-relocatable code. */
    JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);

    /* Here the residual arity is given as zero: it's too late to
       skip residuals, since we've already jumped and this code is
       unreachable.  The instruction pointer, if any, is advanced
       in the non-relocatable code. */
    JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-call/n8/retR, _eREPLACEMENT_mcall__n8__retR, 0)

    /* Relocated code will jump to this label in non-relocated code. */
  JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
    JITTER_COMMENT_IN_ASM_("!REPLACEMENT-call/n8/retR non-relocatable code");
#endif // #ifdef JITTER_REPLICATE
#if defined(JITTER_DISPATCH_NO_THREADING)             \
    && (! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)  \
        || /* is this a replacement? */ 1)
  /* We use the implicit argument at the end of the calling.
     instruction to discover the procedure return address. */
  const void * const _jitter_return_pointer
    __attribute__ ((unused)) = JITTER_ARGP1;
  /* And make it accessible to the user (who will usually call 
     JITTER_BRANCH_AND_LINK) thru a nice macro. */
# define _JITTER_RETURN_ADDRESS _jitter_return_pointer
#endif

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of !REPLACEMENT-call/n8/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  no. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
//#if 0
  //fprintf (stderr, "Executing instruction %s..\n", "!REPLACEMENT-call/n8/retR"); fflush (stderr);
  //fprintf (stderr, "Executing replacement instruction %s..\n", "!REPLACEMENT-call/n8/retR"); fflush (stderr);
  //fprintf (stderr, "Executing non-relocatable instruction %s with JITTER_SPECIALIZED_INSTRUCTION_WORD_NO=%i..\n", "!REPLACEMENT-call/n8/retR", (int) JITTER_SPECIALIZED_INSTRUCTION_WORD_NO); fflush (stderr);
  //fprintf (stderr, "Executing caller replcament: _JITTER_RETURN_ADDRESS is %p..\n", _JITTER_RETURN_ADDRESS); fflush (stderr);
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#undef JITTER_THIS_IS_A_REPLACEMENT
#define JITTER_THIS_IS_A_REPLACEMENT 1

    /* User code for !REPLACEMENT-call/n8/retR . */
  {
/* User-specified code, user code block part: beginning. */

    const jitter_uint in_arity = JITTER_ARGN0;
    jitterlisp_object callee = JITTER_AT_DEPTH_MAINSTACK(in_arity);
    struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(callee);

    if (c->kind == jitterlisp_closure_type_compiled)
      {
        /* Make place for the return address in the return stack.  The
           actual value will be written by the callee. */
        JITTER_PUSH_UNSPECIFIED_RETURNSTACK();

        /* Branch-and-link to the native code, whose first instruction
           will be a prolog. */
        struct jitterlisp_compiled_closure *cc = & c->compiled;
        JITTER_BRANCH_AND_LINK(cc->first_program_point);
      }
    else
      {
        const struct jitterlisp_interpreted_closure *ic = & c->interpreted;

        /* Push an element on the main stack.  This way we can ensure that
           every actual is accessible thru memory in a contiguous array,
           even if the main stack is TOS-optimized.  Compute the address
           (on the main stack backing) where the actuals begin.

           Notice that the interpreted function we are calling is allowed
           to call into compiled code in its turn.  This is not a problem,
           as we are not moving stack pointers down until the call ends:
           the unused part of the main and return stacks is available to
           the callee. */
        JITTER_PUSH_UNSPECIFIED_MAINSTACK();
        jitterlisp_object *actuals
          // FIXME: add a stack operator to compute this address.
          = (& JITTER_UNDER_TOP_MAINSTACK()) - in_arity + 1;

        /* Call the interpreter. */
        jitterlisp_object interpretation_result
          = jitterlisp_call_interpreted (ic, actuals, in_arity);

        /* Remove as many elements as the in-arity plus one (the callee) from
           the stack, without affecting the top.  Unless JITTER_ARGN0 is
           residual this whole loops compiles to one instruction when the main
           stack is TOS-optimized, and doesn't touch memory. */
        int i;
        for (i = 0; i < in_arity + 1; i ++)
          JITTER_NIP_MAINSTACK();

        /* Now the stack is one element higher than it was before the call,
           containing the unspecified element at the top.  Replace it with
           the result.  Again this doesn't touch memory. */
        JITTER_TOP_MAINSTACK() = interpretation_result;
      }
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for !REPLACEMENT-call/n8/retR . */

  //fprintf (stderr, "..Executed replacement instruction %s\n", "!REPLACEMENT-call/n8/retR");
  //fprintf (stderr, "..Executed instruction %s\n", "!REPLACEMENT-call/n8/retR");
//#endif // #if 0
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
#ifdef JITTER_REPLICATE
  {
    /* Advance the instruction pointer, if any, to skip every
       residual but the last; branch back to replicated
       code. */
    const void *_jitter_back_to_replicated_code_pointer =
      JITTER_ARGP1;
    JITTER_SKIP_RESIDUALS_;
    goto * _jitter_back_to_replicated_code_pointer;
  }
#endif // #ifdef JITTER_REPLICATE

    /* Undefine the !REPLACEMENT-call/n8/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#if    defined(JITTER_DISPATCH_NO_THREADING)         \
    && ! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)
# undef _JITTER_RETURN_ADDRESS
#endif

#ifndef JITTER_REPLICATE
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-call/n8/retR, _eREPLACEMENT_mcall__n8__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#endif // #ifndef JITTER_REPLICATE
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for !REPLACEMENT-call/n8/retR, which started with its
       definitions. */
  }
#endif // #if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
/*  End of !REPLACEMENT-call/n8/retR , a replacement specialised instruction */

  /* Ordinary specialised instruction !REPLACEMENT-call/n9/retR (replacement) */
  /* Omit this specialised instruction altogether unless
     replacements are in fact supported in this
     configuration. */
#if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
  JITTER_INSTRUCTION_PROLOG_(!REPLACEMENT-call/n9/retR, _eREPLACEMENT_mcall__n9__retR, cold)
  { /* This block begins with definitions for !REPLACEMENT-call/n9/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       243
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         !REPLACEMENT-call/n9/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "call"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "!REPLACEMENT-call/n9/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _eREPLACEMENT_mcall__n9__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement and a caller.
       Its 1-th argument, a literal, is the return address where to jump
       back after the procedure returns.  Branch-and-link
       functionality is enabled for this instruction. */
/* This instruction is non-relocatable: use branches which
   cannot ever generate defects. */
#   undef JITTER_BRANCH_AND_LINK
#   define JITTER_BRANCH_AND_LINK      _JITTER_BRANCH_AND_LINK_FALLBACK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   define JITTER_BRANCH_AND_LINK_WITH _JITTER_BRANCH_AND_LINK_WITH_FALLBACK
#   undef JITTER_BRANCH_FAST_AND_LINK
#   define JITTER_BRANCH_FAST_AND_LINK _JITTER_BRANCH_AND_LINK_FALLBACK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1

    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 9L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1


#ifdef JITTER_REPLICATE
/* When jumping to the non-relocatable part it is important not
   to use a fallback version of JITTER_COMPUTED_GOTO, in order to
   prevent GCC from tail-merging. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
    /* Jump to non-relocatable code. */
    JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);

    /* Here the residual arity is given as zero: it's too late to
       skip residuals, since we've already jumped and this code is
       unreachable.  The instruction pointer, if any, is advanced
       in the non-relocatable code. */
    JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-call/n9/retR, _eREPLACEMENT_mcall__n9__retR, 0)

    /* Relocated code will jump to this label in non-relocated code. */
  JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
    JITTER_COMMENT_IN_ASM_("!REPLACEMENT-call/n9/retR non-relocatable code");
#endif // #ifdef JITTER_REPLICATE
#if defined(JITTER_DISPATCH_NO_THREADING)             \
    && (! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)  \
        || /* is this a replacement? */ 1)
  /* We use the implicit argument at the end of the calling.
     instruction to discover the procedure return address. */
  const void * const _jitter_return_pointer
    __attribute__ ((unused)) = JITTER_ARGP1;
  /* And make it accessible to the user (who will usually call 
     JITTER_BRANCH_AND_LINK) thru a nice macro. */
# define _JITTER_RETURN_ADDRESS _jitter_return_pointer
#endif

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of !REPLACEMENT-call/n9/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  no. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
//#if 0
  //fprintf (stderr, "Executing instruction %s..\n", "!REPLACEMENT-call/n9/retR"); fflush (stderr);
  //fprintf (stderr, "Executing replacement instruction %s..\n", "!REPLACEMENT-call/n9/retR"); fflush (stderr);
  //fprintf (stderr, "Executing non-relocatable instruction %s with JITTER_SPECIALIZED_INSTRUCTION_WORD_NO=%i..\n", "!REPLACEMENT-call/n9/retR", (int) JITTER_SPECIALIZED_INSTRUCTION_WORD_NO); fflush (stderr);
  //fprintf (stderr, "Executing caller replcament: _JITTER_RETURN_ADDRESS is %p..\n", _JITTER_RETURN_ADDRESS); fflush (stderr);
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#undef JITTER_THIS_IS_A_REPLACEMENT
#define JITTER_THIS_IS_A_REPLACEMENT 1

    /* User code for !REPLACEMENT-call/n9/retR . */
  {
/* User-specified code, user code block part: beginning. */

    const jitter_uint in_arity = JITTER_ARGN0;
    jitterlisp_object callee = JITTER_AT_DEPTH_MAINSTACK(in_arity);
    struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(callee);

    if (c->kind == jitterlisp_closure_type_compiled)
      {
        /* Make place for the return address in the return stack.  The
           actual value will be written by the callee. */
        JITTER_PUSH_UNSPECIFIED_RETURNSTACK();

        /* Branch-and-link to the native code, whose first instruction
           will be a prolog. */
        struct jitterlisp_compiled_closure *cc = & c->compiled;
        JITTER_BRANCH_AND_LINK(cc->first_program_point);
      }
    else
      {
        const struct jitterlisp_interpreted_closure *ic = & c->interpreted;

        /* Push an element on the main stack.  This way we can ensure that
           every actual is accessible thru memory in a contiguous array,
           even if the main stack is TOS-optimized.  Compute the address
           (on the main stack backing) where the actuals begin.

           Notice that the interpreted function we are calling is allowed
           to call into compiled code in its turn.  This is not a problem,
           as we are not moving stack pointers down until the call ends:
           the unused part of the main and return stacks is available to
           the callee. */
        JITTER_PUSH_UNSPECIFIED_MAINSTACK();
        jitterlisp_object *actuals
          // FIXME: add a stack operator to compute this address.
          = (& JITTER_UNDER_TOP_MAINSTACK()) - in_arity + 1;

        /* Call the interpreter. */
        jitterlisp_object interpretation_result
          = jitterlisp_call_interpreted (ic, actuals, in_arity);

        /* Remove as many elements as the in-arity plus one (the callee) from
           the stack, without affecting the top.  Unless JITTER_ARGN0 is
           residual this whole loops compiles to one instruction when the main
           stack is TOS-optimized, and doesn't touch memory. */
        int i;
        for (i = 0; i < in_arity + 1; i ++)
          JITTER_NIP_MAINSTACK();

        /* Now the stack is one element higher than it was before the call,
           containing the unspecified element at the top.  Replace it with
           the result.  Again this doesn't touch memory. */
        JITTER_TOP_MAINSTACK() = interpretation_result;
      }
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for !REPLACEMENT-call/n9/retR . */

  //fprintf (stderr, "..Executed replacement instruction %s\n", "!REPLACEMENT-call/n9/retR");
  //fprintf (stderr, "..Executed instruction %s\n", "!REPLACEMENT-call/n9/retR");
//#endif // #if 0
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
#ifdef JITTER_REPLICATE
  {
    /* Advance the instruction pointer, if any, to skip every
       residual but the last; branch back to replicated
       code. */
    const void *_jitter_back_to_replicated_code_pointer =
      JITTER_ARGP1;
    JITTER_SKIP_RESIDUALS_;
    goto * _jitter_back_to_replicated_code_pointer;
  }
#endif // #ifdef JITTER_REPLICATE

    /* Undefine the !REPLACEMENT-call/n9/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#if    defined(JITTER_DISPATCH_NO_THREADING)         \
    && ! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)
# undef _JITTER_RETURN_ADDRESS
#endif

#ifndef JITTER_REPLICATE
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-call/n9/retR, _eREPLACEMENT_mcall__n9__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#endif // #ifndef JITTER_REPLICATE
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for !REPLACEMENT-call/n9/retR, which started with its
       definitions. */
  }
#endif // #if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
/*  End of !REPLACEMENT-call/n9/retR , a replacement specialised instruction */

  /* Ordinary specialised instruction !REPLACEMENT-call/n10/retR (replacement) */
  /* Omit this specialised instruction altogether unless
     replacements are in fact supported in this
     configuration. */
#if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
  JITTER_INSTRUCTION_PROLOG_(!REPLACEMENT-call/n10/retR, _eREPLACEMENT_mcall__n10__retR, cold)
  { /* This block begins with definitions for !REPLACEMENT-call/n10/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       244
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         !REPLACEMENT-call/n10/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "call"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "!REPLACEMENT-call/n10/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _eREPLACEMENT_mcall__n10__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement and a caller.
       Its 1-th argument, a literal, is the return address where to jump
       back after the procedure returns.  Branch-and-link
       functionality is enabled for this instruction. */
/* This instruction is non-relocatable: use branches which
   cannot ever generate defects. */
#   undef JITTER_BRANCH_AND_LINK
#   define JITTER_BRANCH_AND_LINK      _JITTER_BRANCH_AND_LINK_FALLBACK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   define JITTER_BRANCH_AND_LINK_WITH _JITTER_BRANCH_AND_LINK_WITH_FALLBACK
#   undef JITTER_BRANCH_FAST_AND_LINK
#   define JITTER_BRANCH_FAST_AND_LINK _JITTER_BRANCH_AND_LINK_FALLBACK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1

    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 10L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1


#ifdef JITTER_REPLICATE
/* When jumping to the non-relocatable part it is important not
   to use a fallback version of JITTER_COMPUTED_GOTO, in order to
   prevent GCC from tail-merging. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
    /* Jump to non-relocatable code. */
    JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);

    /* Here the residual arity is given as zero: it's too late to
       skip residuals, since we've already jumped and this code is
       unreachable.  The instruction pointer, if any, is advanced
       in the non-relocatable code. */
    JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-call/n10/retR, _eREPLACEMENT_mcall__n10__retR, 0)

    /* Relocated code will jump to this label in non-relocated code. */
  JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
    JITTER_COMMENT_IN_ASM_("!REPLACEMENT-call/n10/retR non-relocatable code");
#endif // #ifdef JITTER_REPLICATE
#if defined(JITTER_DISPATCH_NO_THREADING)             \
    && (! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)  \
        || /* is this a replacement? */ 1)
  /* We use the implicit argument at the end of the calling.
     instruction to discover the procedure return address. */
  const void * const _jitter_return_pointer
    __attribute__ ((unused)) = JITTER_ARGP1;
  /* And make it accessible to the user (who will usually call 
     JITTER_BRANCH_AND_LINK) thru a nice macro. */
# define _JITTER_RETURN_ADDRESS _jitter_return_pointer
#endif

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of !REPLACEMENT-call/n10/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  no. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
//#if 0
  //fprintf (stderr, "Executing instruction %s..\n", "!REPLACEMENT-call/n10/retR"); fflush (stderr);
  //fprintf (stderr, "Executing replacement instruction %s..\n", "!REPLACEMENT-call/n10/retR"); fflush (stderr);
  //fprintf (stderr, "Executing non-relocatable instruction %s with JITTER_SPECIALIZED_INSTRUCTION_WORD_NO=%i..\n", "!REPLACEMENT-call/n10/retR", (int) JITTER_SPECIALIZED_INSTRUCTION_WORD_NO); fflush (stderr);
  //fprintf (stderr, "Executing caller replcament: _JITTER_RETURN_ADDRESS is %p..\n", _JITTER_RETURN_ADDRESS); fflush (stderr);
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#undef JITTER_THIS_IS_A_REPLACEMENT
#define JITTER_THIS_IS_A_REPLACEMENT 1

    /* User code for !REPLACEMENT-call/n10/retR . */
  {
/* User-specified code, user code block part: beginning. */

    const jitter_uint in_arity = JITTER_ARGN0;
    jitterlisp_object callee = JITTER_AT_DEPTH_MAINSTACK(in_arity);
    struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(callee);

    if (c->kind == jitterlisp_closure_type_compiled)
      {
        /* Make place for the return address in the return stack.  The
           actual value will be written by the callee. */
        JITTER_PUSH_UNSPECIFIED_RETURNSTACK();

        /* Branch-and-link to the native code, whose first instruction
           will be a prolog. */
        struct jitterlisp_compiled_closure *cc = & c->compiled;
        JITTER_BRANCH_AND_LINK(cc->first_program_point);
      }
    else
      {
        const struct jitterlisp_interpreted_closure *ic = & c->interpreted;

        /* Push an element on the main stack.  This way we can ensure that
           every actual is accessible thru memory in a contiguous array,
           even if the main stack is TOS-optimized.  Compute the address
           (on the main stack backing) where the actuals begin.

           Notice that the interpreted function we are calling is allowed
           to call into compiled code in its turn.  This is not a problem,
           as we are not moving stack pointers down until the call ends:
           the unused part of the main and return stacks is available to
           the callee. */
        JITTER_PUSH_UNSPECIFIED_MAINSTACK();
        jitterlisp_object *actuals
          // FIXME: add a stack operator to compute this address.
          = (& JITTER_UNDER_TOP_MAINSTACK()) - in_arity + 1;

        /* Call the interpreter. */
        jitterlisp_object interpretation_result
          = jitterlisp_call_interpreted (ic, actuals, in_arity);

        /* Remove as many elements as the in-arity plus one (the callee) from
           the stack, without affecting the top.  Unless JITTER_ARGN0 is
           residual this whole loops compiles to one instruction when the main
           stack is TOS-optimized, and doesn't touch memory. */
        int i;
        for (i = 0; i < in_arity + 1; i ++)
          JITTER_NIP_MAINSTACK();

        /* Now the stack is one element higher than it was before the call,
           containing the unspecified element at the top.  Replace it with
           the result.  Again this doesn't touch memory. */
        JITTER_TOP_MAINSTACK() = interpretation_result;
      }
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for !REPLACEMENT-call/n10/retR . */

  //fprintf (stderr, "..Executed replacement instruction %s\n", "!REPLACEMENT-call/n10/retR");
  //fprintf (stderr, "..Executed instruction %s\n", "!REPLACEMENT-call/n10/retR");
//#endif // #if 0
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
#ifdef JITTER_REPLICATE
  {
    /* Advance the instruction pointer, if any, to skip every
       residual but the last; branch back to replicated
       code. */
    const void *_jitter_back_to_replicated_code_pointer =
      JITTER_ARGP1;
    JITTER_SKIP_RESIDUALS_;
    goto * _jitter_back_to_replicated_code_pointer;
  }
#endif // #ifdef JITTER_REPLICATE

    /* Undefine the !REPLACEMENT-call/n10/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#if    defined(JITTER_DISPATCH_NO_THREADING)         \
    && ! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)
# undef _JITTER_RETURN_ADDRESS
#endif

#ifndef JITTER_REPLICATE
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-call/n10/retR, _eREPLACEMENT_mcall__n10__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#endif // #ifndef JITTER_REPLICATE
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for !REPLACEMENT-call/n10/retR, which started with its
       definitions. */
  }
#endif // #if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
/*  End of !REPLACEMENT-call/n10/retR , a replacement specialised instruction */

  /* Ordinary specialised instruction !REPLACEMENT-call/nR/retR (replacement) */
  /* Omit this specialised instruction altogether unless
     replacements are in fact supported in this
     configuration. */
#if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
  JITTER_INSTRUCTION_PROLOG_(!REPLACEMENT-call/nR/retR, _eREPLACEMENT_mcall__nR__retR, cold)
  { /* This block begins with definitions for !REPLACEMENT-call/nR/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       245
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         !REPLACEMENT-call/nR/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "call"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "!REPLACEMENT-call/nR/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _eREPLACEMENT_mcall__nR__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement and a caller.
       Its 1-th argument, a literal, is the return address where to jump
       back after the procedure returns.  Branch-and-link
       functionality is enabled for this instruction. */
/* This instruction is non-relocatable: use branches which
   cannot ever generate defects. */
#   undef JITTER_BRANCH_AND_LINK
#   define JITTER_BRANCH_AND_LINK      _JITTER_BRANCH_AND_LINK_FALLBACK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   define JITTER_BRANCH_AND_LINK_WITH _JITTER_BRANCH_AND_LINK_WITH_FALLBACK
#   undef JITTER_BRANCH_FAST_AND_LINK
#   define JITTER_BRANCH_FAST_AND_LINK _JITTER_BRANCH_AND_LINK_FALLBACK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 2

    /* The 0th argument is a residual literal. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1


#ifdef JITTER_REPLICATE
/* When jumping to the non-relocatable part it is important not
   to use a fallback version of JITTER_COMPUTED_GOTO, in order to
   prevent GCC from tail-merging. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
    /* Jump to non-relocatable code. */
    JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);

    /* Here the residual arity is given as zero: it's too late to
       skip residuals, since we've already jumped and this code is
       unreachable.  The instruction pointer, if any, is advanced
       in the non-relocatable code. */
    JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-call/nR/retR, _eREPLACEMENT_mcall__nR__retR, 0)

    /* Relocated code will jump to this label in non-relocated code. */
  JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
    JITTER_COMMENT_IN_ASM_("!REPLACEMENT-call/nR/retR non-relocatable code");
#endif // #ifdef JITTER_REPLICATE
#if defined(JITTER_DISPATCH_NO_THREADING)             \
    && (! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)  \
        || /* is this a replacement? */ 1)
  /* We use the implicit argument at the end of the calling.
     instruction to discover the procedure return address. */
  const void * const _jitter_return_pointer
    __attribute__ ((unused)) = JITTER_ARGP1;
  /* And make it accessible to the user (who will usually call 
     JITTER_BRANCH_AND_LINK) thru a nice macro. */
# define _JITTER_RETURN_ADDRESS _jitter_return_pointer
#endif

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of !REPLACEMENT-call/nR/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  no. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
//#if 0
  //fprintf (stderr, "Executing instruction %s..\n", "!REPLACEMENT-call/nR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing replacement instruction %s..\n", "!REPLACEMENT-call/nR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing non-relocatable instruction %s with JITTER_SPECIALIZED_INSTRUCTION_WORD_NO=%i..\n", "!REPLACEMENT-call/nR/retR", (int) JITTER_SPECIALIZED_INSTRUCTION_WORD_NO); fflush (stderr);
  //fprintf (stderr, "Executing caller replcament: _JITTER_RETURN_ADDRESS is %p..\n", _JITTER_RETURN_ADDRESS); fflush (stderr);
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#undef JITTER_THIS_IS_A_REPLACEMENT
#define JITTER_THIS_IS_A_REPLACEMENT 1

    /* User code for !REPLACEMENT-call/nR/retR . */
  {
/* User-specified code, user code block part: beginning. */

    const jitter_uint in_arity = JITTER_ARGN0;
    jitterlisp_object callee = JITTER_AT_DEPTH_MAINSTACK(in_arity);
    struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(callee);

    if (c->kind == jitterlisp_closure_type_compiled)
      {
        /* Make place for the return address in the return stack.  The
           actual value will be written by the callee. */
        JITTER_PUSH_UNSPECIFIED_RETURNSTACK();

        /* Branch-and-link to the native code, whose first instruction
           will be a prolog. */
        struct jitterlisp_compiled_closure *cc = & c->compiled;
        JITTER_BRANCH_AND_LINK(cc->first_program_point);
      }
    else
      {
        const struct jitterlisp_interpreted_closure *ic = & c->interpreted;

        /* Push an element on the main stack.  This way we can ensure that
           every actual is accessible thru memory in a contiguous array,
           even if the main stack is TOS-optimized.  Compute the address
           (on the main stack backing) where the actuals begin.

           Notice that the interpreted function we are calling is allowed
           to call into compiled code in its turn.  This is not a problem,
           as we are not moving stack pointers down until the call ends:
           the unused part of the main and return stacks is available to
           the callee. */
        JITTER_PUSH_UNSPECIFIED_MAINSTACK();
        jitterlisp_object *actuals
          // FIXME: add a stack operator to compute this address.
          = (& JITTER_UNDER_TOP_MAINSTACK()) - in_arity + 1;

        /* Call the interpreter. */
        jitterlisp_object interpretation_result
          = jitterlisp_call_interpreted (ic, actuals, in_arity);

        /* Remove as many elements as the in-arity plus one (the callee) from
           the stack, without affecting the top.  Unless JITTER_ARGN0 is
           residual this whole loops compiles to one instruction when the main
           stack is TOS-optimized, and doesn't touch memory. */
        int i;
        for (i = 0; i < in_arity + 1; i ++)
          JITTER_NIP_MAINSTACK();

        /* Now the stack is one element higher than it was before the call,
           containing the unspecified element at the top.  Replace it with
           the result.  Again this doesn't touch memory. */
        JITTER_TOP_MAINSTACK() = interpretation_result;
      }
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for !REPLACEMENT-call/nR/retR . */

  //fprintf (stderr, "..Executed replacement instruction %s\n", "!REPLACEMENT-call/nR/retR");
  //fprintf (stderr, "..Executed instruction %s\n", "!REPLACEMENT-call/nR/retR");
//#endif // #if 0
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
#ifdef JITTER_REPLICATE
  {
    /* Advance the instruction pointer, if any, to skip every
       residual but the last; branch back to replicated
       code. */
    const void *_jitter_back_to_replicated_code_pointer =
      JITTER_ARGP1;
    JITTER_SKIP_RESIDUALS_;
    goto * _jitter_back_to_replicated_code_pointer;
  }
#endif // #ifdef JITTER_REPLICATE

    /* Undefine the !REPLACEMENT-call/nR/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#if    defined(JITTER_DISPATCH_NO_THREADING)         \
    && ! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)
# undef _JITTER_RETURN_ADDRESS
#endif

#ifndef JITTER_REPLICATE
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-call/nR/retR, _eREPLACEMENT_mcall__nR__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#endif // #ifndef JITTER_REPLICATE
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for !REPLACEMENT-call/nR/retR, which started with its
       definitions. */
  }
#endif // #if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
/*  End of !REPLACEMENT-call/nR/retR , a replacement specialised instruction */

  /* Ordinary specialised instruction !REPLACEMENT-call-compiled/n0/retR (replacement) */
  /* Omit this specialised instruction altogether unless
     replacements are in fact supported in this
     configuration. */
#if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
  JITTER_INSTRUCTION_PROLOG_(!REPLACEMENT-call-compiled/n0/retR, _eREPLACEMENT_mcall_mcompiled__n0__retR, cold)
  { /* This block begins with definitions for !REPLACEMENT-call-compiled/n0/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       246
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         !REPLACEMENT-call-compiled/n0/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "call-compiled"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "!REPLACEMENT-call-compiled/n0/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _eREPLACEMENT_mcall_mcompiled__n0__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement and a caller.
       Its 1-th argument, a literal, is the return address where to jump
       back after the procedure returns.  Branch-and-link
       functionality is enabled for this instruction. */
/* This instruction is non-relocatable: use branches which
   cannot ever generate defects. */
#   undef JITTER_BRANCH_AND_LINK
#   define JITTER_BRANCH_AND_LINK      _JITTER_BRANCH_AND_LINK_FALLBACK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   define JITTER_BRANCH_AND_LINK_WITH _JITTER_BRANCH_AND_LINK_WITH_FALLBACK
#   undef JITTER_BRANCH_FAST_AND_LINK
#   define JITTER_BRANCH_FAST_AND_LINK _JITTER_BRANCH_AND_LINK_FALLBACK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1

    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 0L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1


#ifdef JITTER_REPLICATE
/* When jumping to the non-relocatable part it is important not
   to use a fallback version of JITTER_COMPUTED_GOTO, in order to
   prevent GCC from tail-merging. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
    /* Jump to non-relocatable code. */
    JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);

    /* Here the residual arity is given as zero: it's too late to
       skip residuals, since we've already jumped and this code is
       unreachable.  The instruction pointer, if any, is advanced
       in the non-relocatable code. */
    JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-call-compiled/n0/retR, _eREPLACEMENT_mcall_mcompiled__n0__retR, 0)

    /* Relocated code will jump to this label in non-relocated code. */
  JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
    JITTER_COMMENT_IN_ASM_("!REPLACEMENT-call-compiled/n0/retR non-relocatable code");
#endif // #ifdef JITTER_REPLICATE
#if defined(JITTER_DISPATCH_NO_THREADING)             \
    && (! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)  \
        || /* is this a replacement? */ 1)
  /* We use the implicit argument at the end of the calling.
     instruction to discover the procedure return address. */
  const void * const _jitter_return_pointer
    __attribute__ ((unused)) = JITTER_ARGP1;
  /* And make it accessible to the user (who will usually call 
     JITTER_BRANCH_AND_LINK) thru a nice macro. */
# define _JITTER_RETURN_ADDRESS _jitter_return_pointer
#endif

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of !REPLACEMENT-call-compiled/n0/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  no. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
//#if 0
  //fprintf (stderr, "Executing instruction %s..\n", "!REPLACEMENT-call-compiled/n0/retR"); fflush (stderr);
  //fprintf (stderr, "Executing replacement instruction %s..\n", "!REPLACEMENT-call-compiled/n0/retR"); fflush (stderr);
  //fprintf (stderr, "Executing non-relocatable instruction %s with JITTER_SPECIALIZED_INSTRUCTION_WORD_NO=%i..\n", "!REPLACEMENT-call-compiled/n0/retR", (int) JITTER_SPECIALIZED_INSTRUCTION_WORD_NO); fflush (stderr);
  //fprintf (stderr, "Executing caller replcament: _JITTER_RETURN_ADDRESS is %p..\n", _JITTER_RETURN_ADDRESS); fflush (stderr);
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#undef JITTER_THIS_IS_A_REPLACEMENT
#define JITTER_THIS_IS_A_REPLACEMENT 1

    /* User code for !REPLACEMENT-call-compiled/n0/retR . */
  {
/* User-specified code, user code block part: beginning. */

    const jitter_uint in_arity = JITTER_ARGN0;
    jitterlisp_object callee = JITTER_AT_DEPTH_MAINSTACK(in_arity);
    struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(callee);

    /* Here we can assume that * c is a compiled closure without checking. */
    struct jitterlisp_compiled_closure *cc = & c->compiled;

    /* Make place for the return address in the return stack.  The
       actual value will be written by the callee. */
    JITTER_PUSH_UNSPECIFIED_RETURNSTACK();
//    JITTER_TOP_RETURNSTACK() = 0x4242aaaa; // FIXME: just a test.  Remove.

    /* Branch-and-link to the native code, whose first instruction
       will be a prolog. */
    JITTER_BRANCH_AND_LINK(cc->first_program_point);
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for !REPLACEMENT-call-compiled/n0/retR . */

  //fprintf (stderr, "..Executed replacement instruction %s\n", "!REPLACEMENT-call-compiled/n0/retR");
  //fprintf (stderr, "..Executed instruction %s\n", "!REPLACEMENT-call-compiled/n0/retR");
//#endif // #if 0
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
#ifdef JITTER_REPLICATE
  {
    /* Advance the instruction pointer, if any, to skip every
       residual but the last; branch back to replicated
       code. */
    const void *_jitter_back_to_replicated_code_pointer =
      JITTER_ARGP1;
    JITTER_SKIP_RESIDUALS_;
    goto * _jitter_back_to_replicated_code_pointer;
  }
#endif // #ifdef JITTER_REPLICATE

    /* Undefine the !REPLACEMENT-call-compiled/n0/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#if    defined(JITTER_DISPATCH_NO_THREADING)         \
    && ! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)
# undef _JITTER_RETURN_ADDRESS
#endif

#ifndef JITTER_REPLICATE
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-call-compiled/n0/retR, _eREPLACEMENT_mcall_mcompiled__n0__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#endif // #ifndef JITTER_REPLICATE
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for !REPLACEMENT-call-compiled/n0/retR, which started with its
       definitions. */
  }
#endif // #if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
/*  End of !REPLACEMENT-call-compiled/n0/retR , a replacement specialised instruction */

  /* Ordinary specialised instruction !REPLACEMENT-call-compiled/n1/retR (replacement) */
  /* Omit this specialised instruction altogether unless
     replacements are in fact supported in this
     configuration. */
#if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
  JITTER_INSTRUCTION_PROLOG_(!REPLACEMENT-call-compiled/n1/retR, _eREPLACEMENT_mcall_mcompiled__n1__retR, cold)
  { /* This block begins with definitions for !REPLACEMENT-call-compiled/n1/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       247
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         !REPLACEMENT-call-compiled/n1/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "call-compiled"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "!REPLACEMENT-call-compiled/n1/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _eREPLACEMENT_mcall_mcompiled__n1__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement and a caller.
       Its 1-th argument, a literal, is the return address where to jump
       back after the procedure returns.  Branch-and-link
       functionality is enabled for this instruction. */
/* This instruction is non-relocatable: use branches which
   cannot ever generate defects. */
#   undef JITTER_BRANCH_AND_LINK
#   define JITTER_BRANCH_AND_LINK      _JITTER_BRANCH_AND_LINK_FALLBACK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   define JITTER_BRANCH_AND_LINK_WITH _JITTER_BRANCH_AND_LINK_WITH_FALLBACK
#   undef JITTER_BRANCH_FAST_AND_LINK
#   define JITTER_BRANCH_FAST_AND_LINK _JITTER_BRANCH_AND_LINK_FALLBACK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1

    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 1L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1


#ifdef JITTER_REPLICATE
/* When jumping to the non-relocatable part it is important not
   to use a fallback version of JITTER_COMPUTED_GOTO, in order to
   prevent GCC from tail-merging. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
    /* Jump to non-relocatable code. */
    JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);

    /* Here the residual arity is given as zero: it's too late to
       skip residuals, since we've already jumped and this code is
       unreachable.  The instruction pointer, if any, is advanced
       in the non-relocatable code. */
    JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-call-compiled/n1/retR, _eREPLACEMENT_mcall_mcompiled__n1__retR, 0)

    /* Relocated code will jump to this label in non-relocated code. */
  JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
    JITTER_COMMENT_IN_ASM_("!REPLACEMENT-call-compiled/n1/retR non-relocatable code");
#endif // #ifdef JITTER_REPLICATE
#if defined(JITTER_DISPATCH_NO_THREADING)             \
    && (! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)  \
        || /* is this a replacement? */ 1)
  /* We use the implicit argument at the end of the calling.
     instruction to discover the procedure return address. */
  const void * const _jitter_return_pointer
    __attribute__ ((unused)) = JITTER_ARGP1;
  /* And make it accessible to the user (who will usually call 
     JITTER_BRANCH_AND_LINK) thru a nice macro. */
# define _JITTER_RETURN_ADDRESS _jitter_return_pointer
#endif

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of !REPLACEMENT-call-compiled/n1/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  no. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
//#if 0
  //fprintf (stderr, "Executing instruction %s..\n", "!REPLACEMENT-call-compiled/n1/retR"); fflush (stderr);
  //fprintf (stderr, "Executing replacement instruction %s..\n", "!REPLACEMENT-call-compiled/n1/retR"); fflush (stderr);
  //fprintf (stderr, "Executing non-relocatable instruction %s with JITTER_SPECIALIZED_INSTRUCTION_WORD_NO=%i..\n", "!REPLACEMENT-call-compiled/n1/retR", (int) JITTER_SPECIALIZED_INSTRUCTION_WORD_NO); fflush (stderr);
  //fprintf (stderr, "Executing caller replcament: _JITTER_RETURN_ADDRESS is %p..\n", _JITTER_RETURN_ADDRESS); fflush (stderr);
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#undef JITTER_THIS_IS_A_REPLACEMENT
#define JITTER_THIS_IS_A_REPLACEMENT 1

    /* User code for !REPLACEMENT-call-compiled/n1/retR . */
  {
/* User-specified code, user code block part: beginning. */

    const jitter_uint in_arity = JITTER_ARGN0;
    jitterlisp_object callee = JITTER_AT_DEPTH_MAINSTACK(in_arity);
    struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(callee);

    /* Here we can assume that * c is a compiled closure without checking. */
    struct jitterlisp_compiled_closure *cc = & c->compiled;

    /* Make place for the return address in the return stack.  The
       actual value will be written by the callee. */
    JITTER_PUSH_UNSPECIFIED_RETURNSTACK();
//    JITTER_TOP_RETURNSTACK() = 0x4242aaaa; // FIXME: just a test.  Remove.

    /* Branch-and-link to the native code, whose first instruction
       will be a prolog. */
    JITTER_BRANCH_AND_LINK(cc->first_program_point);
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for !REPLACEMENT-call-compiled/n1/retR . */

  //fprintf (stderr, "..Executed replacement instruction %s\n", "!REPLACEMENT-call-compiled/n1/retR");
  //fprintf (stderr, "..Executed instruction %s\n", "!REPLACEMENT-call-compiled/n1/retR");
//#endif // #if 0
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
#ifdef JITTER_REPLICATE
  {
    /* Advance the instruction pointer, if any, to skip every
       residual but the last; branch back to replicated
       code. */
    const void *_jitter_back_to_replicated_code_pointer =
      JITTER_ARGP1;
    JITTER_SKIP_RESIDUALS_;
    goto * _jitter_back_to_replicated_code_pointer;
  }
#endif // #ifdef JITTER_REPLICATE

    /* Undefine the !REPLACEMENT-call-compiled/n1/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#if    defined(JITTER_DISPATCH_NO_THREADING)         \
    && ! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)
# undef _JITTER_RETURN_ADDRESS
#endif

#ifndef JITTER_REPLICATE
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-call-compiled/n1/retR, _eREPLACEMENT_mcall_mcompiled__n1__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#endif // #ifndef JITTER_REPLICATE
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for !REPLACEMENT-call-compiled/n1/retR, which started with its
       definitions. */
  }
#endif // #if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
/*  End of !REPLACEMENT-call-compiled/n1/retR , a replacement specialised instruction */

  /* Ordinary specialised instruction !REPLACEMENT-call-compiled/n2/retR (replacement) */
  /* Omit this specialised instruction altogether unless
     replacements are in fact supported in this
     configuration. */
#if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
  JITTER_INSTRUCTION_PROLOG_(!REPLACEMENT-call-compiled/n2/retR, _eREPLACEMENT_mcall_mcompiled__n2__retR, cold)
  { /* This block begins with definitions for !REPLACEMENT-call-compiled/n2/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       248
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         !REPLACEMENT-call-compiled/n2/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "call-compiled"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "!REPLACEMENT-call-compiled/n2/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _eREPLACEMENT_mcall_mcompiled__n2__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement and a caller.
       Its 1-th argument, a literal, is the return address where to jump
       back after the procedure returns.  Branch-and-link
       functionality is enabled for this instruction. */
/* This instruction is non-relocatable: use branches which
   cannot ever generate defects. */
#   undef JITTER_BRANCH_AND_LINK
#   define JITTER_BRANCH_AND_LINK      _JITTER_BRANCH_AND_LINK_FALLBACK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   define JITTER_BRANCH_AND_LINK_WITH _JITTER_BRANCH_AND_LINK_WITH_FALLBACK
#   undef JITTER_BRANCH_FAST_AND_LINK
#   define JITTER_BRANCH_FAST_AND_LINK _JITTER_BRANCH_AND_LINK_FALLBACK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1

    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 2L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1


#ifdef JITTER_REPLICATE
/* When jumping to the non-relocatable part it is important not
   to use a fallback version of JITTER_COMPUTED_GOTO, in order to
   prevent GCC from tail-merging. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
    /* Jump to non-relocatable code. */
    JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);

    /* Here the residual arity is given as zero: it's too late to
       skip residuals, since we've already jumped and this code is
       unreachable.  The instruction pointer, if any, is advanced
       in the non-relocatable code. */
    JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-call-compiled/n2/retR, _eREPLACEMENT_mcall_mcompiled__n2__retR, 0)

    /* Relocated code will jump to this label in non-relocated code. */
  JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
    JITTER_COMMENT_IN_ASM_("!REPLACEMENT-call-compiled/n2/retR non-relocatable code");
#endif // #ifdef JITTER_REPLICATE
#if defined(JITTER_DISPATCH_NO_THREADING)             \
    && (! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)  \
        || /* is this a replacement? */ 1)
  /* We use the implicit argument at the end of the calling.
     instruction to discover the procedure return address. */
  const void * const _jitter_return_pointer
    __attribute__ ((unused)) = JITTER_ARGP1;
  /* And make it accessible to the user (who will usually call 
     JITTER_BRANCH_AND_LINK) thru a nice macro. */
# define _JITTER_RETURN_ADDRESS _jitter_return_pointer
#endif

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of !REPLACEMENT-call-compiled/n2/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  no. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
//#if 0
  //fprintf (stderr, "Executing instruction %s..\n", "!REPLACEMENT-call-compiled/n2/retR"); fflush (stderr);
  //fprintf (stderr, "Executing replacement instruction %s..\n", "!REPLACEMENT-call-compiled/n2/retR"); fflush (stderr);
  //fprintf (stderr, "Executing non-relocatable instruction %s with JITTER_SPECIALIZED_INSTRUCTION_WORD_NO=%i..\n", "!REPLACEMENT-call-compiled/n2/retR", (int) JITTER_SPECIALIZED_INSTRUCTION_WORD_NO); fflush (stderr);
  //fprintf (stderr, "Executing caller replcament: _JITTER_RETURN_ADDRESS is %p..\n", _JITTER_RETURN_ADDRESS); fflush (stderr);
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#undef JITTER_THIS_IS_A_REPLACEMENT
#define JITTER_THIS_IS_A_REPLACEMENT 1

    /* User code for !REPLACEMENT-call-compiled/n2/retR . */
  {
/* User-specified code, user code block part: beginning. */

    const jitter_uint in_arity = JITTER_ARGN0;
    jitterlisp_object callee = JITTER_AT_DEPTH_MAINSTACK(in_arity);
    struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(callee);

    /* Here we can assume that * c is a compiled closure without checking. */
    struct jitterlisp_compiled_closure *cc = & c->compiled;

    /* Make place for the return address in the return stack.  The
       actual value will be written by the callee. */
    JITTER_PUSH_UNSPECIFIED_RETURNSTACK();
//    JITTER_TOP_RETURNSTACK() = 0x4242aaaa; // FIXME: just a test.  Remove.

    /* Branch-and-link to the native code, whose first instruction
       will be a prolog. */
    JITTER_BRANCH_AND_LINK(cc->first_program_point);
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for !REPLACEMENT-call-compiled/n2/retR . */

  //fprintf (stderr, "..Executed replacement instruction %s\n", "!REPLACEMENT-call-compiled/n2/retR");
  //fprintf (stderr, "..Executed instruction %s\n", "!REPLACEMENT-call-compiled/n2/retR");
//#endif // #if 0
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
#ifdef JITTER_REPLICATE
  {
    /* Advance the instruction pointer, if any, to skip every
       residual but the last; branch back to replicated
       code. */
    const void *_jitter_back_to_replicated_code_pointer =
      JITTER_ARGP1;
    JITTER_SKIP_RESIDUALS_;
    goto * _jitter_back_to_replicated_code_pointer;
  }
#endif // #ifdef JITTER_REPLICATE

    /* Undefine the !REPLACEMENT-call-compiled/n2/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#if    defined(JITTER_DISPATCH_NO_THREADING)         \
    && ! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)
# undef _JITTER_RETURN_ADDRESS
#endif

#ifndef JITTER_REPLICATE
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-call-compiled/n2/retR, _eREPLACEMENT_mcall_mcompiled__n2__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#endif // #ifndef JITTER_REPLICATE
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for !REPLACEMENT-call-compiled/n2/retR, which started with its
       definitions. */
  }
#endif // #if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
/*  End of !REPLACEMENT-call-compiled/n2/retR , a replacement specialised instruction */

  /* Ordinary specialised instruction !REPLACEMENT-call-compiled/n3/retR (replacement) */
  /* Omit this specialised instruction altogether unless
     replacements are in fact supported in this
     configuration. */
#if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
  JITTER_INSTRUCTION_PROLOG_(!REPLACEMENT-call-compiled/n3/retR, _eREPLACEMENT_mcall_mcompiled__n3__retR, cold)
  { /* This block begins with definitions for !REPLACEMENT-call-compiled/n3/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       249
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         !REPLACEMENT-call-compiled/n3/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "call-compiled"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "!REPLACEMENT-call-compiled/n3/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _eREPLACEMENT_mcall_mcompiled__n3__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement and a caller.
       Its 1-th argument, a literal, is the return address where to jump
       back after the procedure returns.  Branch-and-link
       functionality is enabled for this instruction. */
/* This instruction is non-relocatable: use branches which
   cannot ever generate defects. */
#   undef JITTER_BRANCH_AND_LINK
#   define JITTER_BRANCH_AND_LINK      _JITTER_BRANCH_AND_LINK_FALLBACK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   define JITTER_BRANCH_AND_LINK_WITH _JITTER_BRANCH_AND_LINK_WITH_FALLBACK
#   undef JITTER_BRANCH_FAST_AND_LINK
#   define JITTER_BRANCH_FAST_AND_LINK _JITTER_BRANCH_AND_LINK_FALLBACK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1

    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 3L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1


#ifdef JITTER_REPLICATE
/* When jumping to the non-relocatable part it is important not
   to use a fallback version of JITTER_COMPUTED_GOTO, in order to
   prevent GCC from tail-merging. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
    /* Jump to non-relocatable code. */
    JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);

    /* Here the residual arity is given as zero: it's too late to
       skip residuals, since we've already jumped and this code is
       unreachable.  The instruction pointer, if any, is advanced
       in the non-relocatable code. */
    JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-call-compiled/n3/retR, _eREPLACEMENT_mcall_mcompiled__n3__retR, 0)

    /* Relocated code will jump to this label in non-relocated code. */
  JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
    JITTER_COMMENT_IN_ASM_("!REPLACEMENT-call-compiled/n3/retR non-relocatable code");
#endif // #ifdef JITTER_REPLICATE
#if defined(JITTER_DISPATCH_NO_THREADING)             \
    && (! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)  \
        || /* is this a replacement? */ 1)
  /* We use the implicit argument at the end of the calling.
     instruction to discover the procedure return address. */
  const void * const _jitter_return_pointer
    __attribute__ ((unused)) = JITTER_ARGP1;
  /* And make it accessible to the user (who will usually call 
     JITTER_BRANCH_AND_LINK) thru a nice macro. */
# define _JITTER_RETURN_ADDRESS _jitter_return_pointer
#endif

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of !REPLACEMENT-call-compiled/n3/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  no. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
//#if 0
  //fprintf (stderr, "Executing instruction %s..\n", "!REPLACEMENT-call-compiled/n3/retR"); fflush (stderr);
  //fprintf (stderr, "Executing replacement instruction %s..\n", "!REPLACEMENT-call-compiled/n3/retR"); fflush (stderr);
  //fprintf (stderr, "Executing non-relocatable instruction %s with JITTER_SPECIALIZED_INSTRUCTION_WORD_NO=%i..\n", "!REPLACEMENT-call-compiled/n3/retR", (int) JITTER_SPECIALIZED_INSTRUCTION_WORD_NO); fflush (stderr);
  //fprintf (stderr, "Executing caller replcament: _JITTER_RETURN_ADDRESS is %p..\n", _JITTER_RETURN_ADDRESS); fflush (stderr);
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#undef JITTER_THIS_IS_A_REPLACEMENT
#define JITTER_THIS_IS_A_REPLACEMENT 1

    /* User code for !REPLACEMENT-call-compiled/n3/retR . */
  {
/* User-specified code, user code block part: beginning. */

    const jitter_uint in_arity = JITTER_ARGN0;
    jitterlisp_object callee = JITTER_AT_DEPTH_MAINSTACK(in_arity);
    struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(callee);

    /* Here we can assume that * c is a compiled closure without checking. */
    struct jitterlisp_compiled_closure *cc = & c->compiled;

    /* Make place for the return address in the return stack.  The
       actual value will be written by the callee. */
    JITTER_PUSH_UNSPECIFIED_RETURNSTACK();
//    JITTER_TOP_RETURNSTACK() = 0x4242aaaa; // FIXME: just a test.  Remove.

    /* Branch-and-link to the native code, whose first instruction
       will be a prolog. */
    JITTER_BRANCH_AND_LINK(cc->first_program_point);
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for !REPLACEMENT-call-compiled/n3/retR . */

  //fprintf (stderr, "..Executed replacement instruction %s\n", "!REPLACEMENT-call-compiled/n3/retR");
  //fprintf (stderr, "..Executed instruction %s\n", "!REPLACEMENT-call-compiled/n3/retR");
//#endif // #if 0
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
#ifdef JITTER_REPLICATE
  {
    /* Advance the instruction pointer, if any, to skip every
       residual but the last; branch back to replicated
       code. */
    const void *_jitter_back_to_replicated_code_pointer =
      JITTER_ARGP1;
    JITTER_SKIP_RESIDUALS_;
    goto * _jitter_back_to_replicated_code_pointer;
  }
#endif // #ifdef JITTER_REPLICATE

    /* Undefine the !REPLACEMENT-call-compiled/n3/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#if    defined(JITTER_DISPATCH_NO_THREADING)         \
    && ! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)
# undef _JITTER_RETURN_ADDRESS
#endif

#ifndef JITTER_REPLICATE
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-call-compiled/n3/retR, _eREPLACEMENT_mcall_mcompiled__n3__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#endif // #ifndef JITTER_REPLICATE
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for !REPLACEMENT-call-compiled/n3/retR, which started with its
       definitions. */
  }
#endif // #if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
/*  End of !REPLACEMENT-call-compiled/n3/retR , a replacement specialised instruction */

  /* Ordinary specialised instruction !REPLACEMENT-call-compiled/n4/retR (replacement) */
  /* Omit this specialised instruction altogether unless
     replacements are in fact supported in this
     configuration. */
#if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
  JITTER_INSTRUCTION_PROLOG_(!REPLACEMENT-call-compiled/n4/retR, _eREPLACEMENT_mcall_mcompiled__n4__retR, cold)
  { /* This block begins with definitions for !REPLACEMENT-call-compiled/n4/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       250
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         !REPLACEMENT-call-compiled/n4/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "call-compiled"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "!REPLACEMENT-call-compiled/n4/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _eREPLACEMENT_mcall_mcompiled__n4__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement and a caller.
       Its 1-th argument, a literal, is the return address where to jump
       back after the procedure returns.  Branch-and-link
       functionality is enabled for this instruction. */
/* This instruction is non-relocatable: use branches which
   cannot ever generate defects. */
#   undef JITTER_BRANCH_AND_LINK
#   define JITTER_BRANCH_AND_LINK      _JITTER_BRANCH_AND_LINK_FALLBACK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   define JITTER_BRANCH_AND_LINK_WITH _JITTER_BRANCH_AND_LINK_WITH_FALLBACK
#   undef JITTER_BRANCH_FAST_AND_LINK
#   define JITTER_BRANCH_FAST_AND_LINK _JITTER_BRANCH_AND_LINK_FALLBACK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1

    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 4L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1


#ifdef JITTER_REPLICATE
/* When jumping to the non-relocatable part it is important not
   to use a fallback version of JITTER_COMPUTED_GOTO, in order to
   prevent GCC from tail-merging. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
    /* Jump to non-relocatable code. */
    JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);

    /* Here the residual arity is given as zero: it's too late to
       skip residuals, since we've already jumped and this code is
       unreachable.  The instruction pointer, if any, is advanced
       in the non-relocatable code. */
    JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-call-compiled/n4/retR, _eREPLACEMENT_mcall_mcompiled__n4__retR, 0)

    /* Relocated code will jump to this label in non-relocated code. */
  JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
    JITTER_COMMENT_IN_ASM_("!REPLACEMENT-call-compiled/n4/retR non-relocatable code");
#endif // #ifdef JITTER_REPLICATE
#if defined(JITTER_DISPATCH_NO_THREADING)             \
    && (! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)  \
        || /* is this a replacement? */ 1)
  /* We use the implicit argument at the end of the calling.
     instruction to discover the procedure return address. */
  const void * const _jitter_return_pointer
    __attribute__ ((unused)) = JITTER_ARGP1;
  /* And make it accessible to the user (who will usually call 
     JITTER_BRANCH_AND_LINK) thru a nice macro. */
# define _JITTER_RETURN_ADDRESS _jitter_return_pointer
#endif

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of !REPLACEMENT-call-compiled/n4/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  no. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
//#if 0
  //fprintf (stderr, "Executing instruction %s..\n", "!REPLACEMENT-call-compiled/n4/retR"); fflush (stderr);
  //fprintf (stderr, "Executing replacement instruction %s..\n", "!REPLACEMENT-call-compiled/n4/retR"); fflush (stderr);
  //fprintf (stderr, "Executing non-relocatable instruction %s with JITTER_SPECIALIZED_INSTRUCTION_WORD_NO=%i..\n", "!REPLACEMENT-call-compiled/n4/retR", (int) JITTER_SPECIALIZED_INSTRUCTION_WORD_NO); fflush (stderr);
  //fprintf (stderr, "Executing caller replcament: _JITTER_RETURN_ADDRESS is %p..\n", _JITTER_RETURN_ADDRESS); fflush (stderr);
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#undef JITTER_THIS_IS_A_REPLACEMENT
#define JITTER_THIS_IS_A_REPLACEMENT 1

    /* User code for !REPLACEMENT-call-compiled/n4/retR . */
  {
/* User-specified code, user code block part: beginning. */

    const jitter_uint in_arity = JITTER_ARGN0;
    jitterlisp_object callee = JITTER_AT_DEPTH_MAINSTACK(in_arity);
    struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(callee);

    /* Here we can assume that * c is a compiled closure without checking. */
    struct jitterlisp_compiled_closure *cc = & c->compiled;

    /* Make place for the return address in the return stack.  The
       actual value will be written by the callee. */
    JITTER_PUSH_UNSPECIFIED_RETURNSTACK();
//    JITTER_TOP_RETURNSTACK() = 0x4242aaaa; // FIXME: just a test.  Remove.

    /* Branch-and-link to the native code, whose first instruction
       will be a prolog. */
    JITTER_BRANCH_AND_LINK(cc->first_program_point);
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for !REPLACEMENT-call-compiled/n4/retR . */

  //fprintf (stderr, "..Executed replacement instruction %s\n", "!REPLACEMENT-call-compiled/n4/retR");
  //fprintf (stderr, "..Executed instruction %s\n", "!REPLACEMENT-call-compiled/n4/retR");
//#endif // #if 0
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
#ifdef JITTER_REPLICATE
  {
    /* Advance the instruction pointer, if any, to skip every
       residual but the last; branch back to replicated
       code. */
    const void *_jitter_back_to_replicated_code_pointer =
      JITTER_ARGP1;
    JITTER_SKIP_RESIDUALS_;
    goto * _jitter_back_to_replicated_code_pointer;
  }
#endif // #ifdef JITTER_REPLICATE

    /* Undefine the !REPLACEMENT-call-compiled/n4/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#if    defined(JITTER_DISPATCH_NO_THREADING)         \
    && ! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)
# undef _JITTER_RETURN_ADDRESS
#endif

#ifndef JITTER_REPLICATE
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-call-compiled/n4/retR, _eREPLACEMENT_mcall_mcompiled__n4__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#endif // #ifndef JITTER_REPLICATE
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for !REPLACEMENT-call-compiled/n4/retR, which started with its
       definitions. */
  }
#endif // #if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
/*  End of !REPLACEMENT-call-compiled/n4/retR , a replacement specialised instruction */

  /* Ordinary specialised instruction !REPLACEMENT-call-compiled/n5/retR (replacement) */
  /* Omit this specialised instruction altogether unless
     replacements are in fact supported in this
     configuration. */
#if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
  JITTER_INSTRUCTION_PROLOG_(!REPLACEMENT-call-compiled/n5/retR, _eREPLACEMENT_mcall_mcompiled__n5__retR, cold)
  { /* This block begins with definitions for !REPLACEMENT-call-compiled/n5/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       251
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         !REPLACEMENT-call-compiled/n5/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "call-compiled"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "!REPLACEMENT-call-compiled/n5/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _eREPLACEMENT_mcall_mcompiled__n5__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement and a caller.
       Its 1-th argument, a literal, is the return address where to jump
       back after the procedure returns.  Branch-and-link
       functionality is enabled for this instruction. */
/* This instruction is non-relocatable: use branches which
   cannot ever generate defects. */
#   undef JITTER_BRANCH_AND_LINK
#   define JITTER_BRANCH_AND_LINK      _JITTER_BRANCH_AND_LINK_FALLBACK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   define JITTER_BRANCH_AND_LINK_WITH _JITTER_BRANCH_AND_LINK_WITH_FALLBACK
#   undef JITTER_BRANCH_FAST_AND_LINK
#   define JITTER_BRANCH_FAST_AND_LINK _JITTER_BRANCH_AND_LINK_FALLBACK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1

    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 5L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1


#ifdef JITTER_REPLICATE
/* When jumping to the non-relocatable part it is important not
   to use a fallback version of JITTER_COMPUTED_GOTO, in order to
   prevent GCC from tail-merging. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
    /* Jump to non-relocatable code. */
    JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);

    /* Here the residual arity is given as zero: it's too late to
       skip residuals, since we've already jumped and this code is
       unreachable.  The instruction pointer, if any, is advanced
       in the non-relocatable code. */
    JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-call-compiled/n5/retR, _eREPLACEMENT_mcall_mcompiled__n5__retR, 0)

    /* Relocated code will jump to this label in non-relocated code. */
  JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
    JITTER_COMMENT_IN_ASM_("!REPLACEMENT-call-compiled/n5/retR non-relocatable code");
#endif // #ifdef JITTER_REPLICATE
#if defined(JITTER_DISPATCH_NO_THREADING)             \
    && (! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)  \
        || /* is this a replacement? */ 1)
  /* We use the implicit argument at the end of the calling.
     instruction to discover the procedure return address. */
  const void * const _jitter_return_pointer
    __attribute__ ((unused)) = JITTER_ARGP1;
  /* And make it accessible to the user (who will usually call 
     JITTER_BRANCH_AND_LINK) thru a nice macro. */
# define _JITTER_RETURN_ADDRESS _jitter_return_pointer
#endif

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of !REPLACEMENT-call-compiled/n5/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  no. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
//#if 0
  //fprintf (stderr, "Executing instruction %s..\n", "!REPLACEMENT-call-compiled/n5/retR"); fflush (stderr);
  //fprintf (stderr, "Executing replacement instruction %s..\n", "!REPLACEMENT-call-compiled/n5/retR"); fflush (stderr);
  //fprintf (stderr, "Executing non-relocatable instruction %s with JITTER_SPECIALIZED_INSTRUCTION_WORD_NO=%i..\n", "!REPLACEMENT-call-compiled/n5/retR", (int) JITTER_SPECIALIZED_INSTRUCTION_WORD_NO); fflush (stderr);
  //fprintf (stderr, "Executing caller replcament: _JITTER_RETURN_ADDRESS is %p..\n", _JITTER_RETURN_ADDRESS); fflush (stderr);
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#undef JITTER_THIS_IS_A_REPLACEMENT
#define JITTER_THIS_IS_A_REPLACEMENT 1

    /* User code for !REPLACEMENT-call-compiled/n5/retR . */
  {
/* User-specified code, user code block part: beginning. */

    const jitter_uint in_arity = JITTER_ARGN0;
    jitterlisp_object callee = JITTER_AT_DEPTH_MAINSTACK(in_arity);
    struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(callee);

    /* Here we can assume that * c is a compiled closure without checking. */
    struct jitterlisp_compiled_closure *cc = & c->compiled;

    /* Make place for the return address in the return stack.  The
       actual value will be written by the callee. */
    JITTER_PUSH_UNSPECIFIED_RETURNSTACK();
//    JITTER_TOP_RETURNSTACK() = 0x4242aaaa; // FIXME: just a test.  Remove.

    /* Branch-and-link to the native code, whose first instruction
       will be a prolog. */
    JITTER_BRANCH_AND_LINK(cc->first_program_point);
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for !REPLACEMENT-call-compiled/n5/retR . */

  //fprintf (stderr, "..Executed replacement instruction %s\n", "!REPLACEMENT-call-compiled/n5/retR");
  //fprintf (stderr, "..Executed instruction %s\n", "!REPLACEMENT-call-compiled/n5/retR");
//#endif // #if 0
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
#ifdef JITTER_REPLICATE
  {
    /* Advance the instruction pointer, if any, to skip every
       residual but the last; branch back to replicated
       code. */
    const void *_jitter_back_to_replicated_code_pointer =
      JITTER_ARGP1;
    JITTER_SKIP_RESIDUALS_;
    goto * _jitter_back_to_replicated_code_pointer;
  }
#endif // #ifdef JITTER_REPLICATE

    /* Undefine the !REPLACEMENT-call-compiled/n5/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#if    defined(JITTER_DISPATCH_NO_THREADING)         \
    && ! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)
# undef _JITTER_RETURN_ADDRESS
#endif

#ifndef JITTER_REPLICATE
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-call-compiled/n5/retR, _eREPLACEMENT_mcall_mcompiled__n5__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#endif // #ifndef JITTER_REPLICATE
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for !REPLACEMENT-call-compiled/n5/retR, which started with its
       definitions. */
  }
#endif // #if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
/*  End of !REPLACEMENT-call-compiled/n5/retR , a replacement specialised instruction */

  /* Ordinary specialised instruction !REPLACEMENT-call-compiled/n6/retR (replacement) */
  /* Omit this specialised instruction altogether unless
     replacements are in fact supported in this
     configuration. */
#if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
  JITTER_INSTRUCTION_PROLOG_(!REPLACEMENT-call-compiled/n6/retR, _eREPLACEMENT_mcall_mcompiled__n6__retR, cold)
  { /* This block begins with definitions for !REPLACEMENT-call-compiled/n6/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       252
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         !REPLACEMENT-call-compiled/n6/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "call-compiled"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "!REPLACEMENT-call-compiled/n6/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _eREPLACEMENT_mcall_mcompiled__n6__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement and a caller.
       Its 1-th argument, a literal, is the return address where to jump
       back after the procedure returns.  Branch-and-link
       functionality is enabled for this instruction. */
/* This instruction is non-relocatable: use branches which
   cannot ever generate defects. */
#   undef JITTER_BRANCH_AND_LINK
#   define JITTER_BRANCH_AND_LINK      _JITTER_BRANCH_AND_LINK_FALLBACK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   define JITTER_BRANCH_AND_LINK_WITH _JITTER_BRANCH_AND_LINK_WITH_FALLBACK
#   undef JITTER_BRANCH_FAST_AND_LINK
#   define JITTER_BRANCH_FAST_AND_LINK _JITTER_BRANCH_AND_LINK_FALLBACK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1

    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 6L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1


#ifdef JITTER_REPLICATE
/* When jumping to the non-relocatable part it is important not
   to use a fallback version of JITTER_COMPUTED_GOTO, in order to
   prevent GCC from tail-merging. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
    /* Jump to non-relocatable code. */
    JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);

    /* Here the residual arity is given as zero: it's too late to
       skip residuals, since we've already jumped and this code is
       unreachable.  The instruction pointer, if any, is advanced
       in the non-relocatable code. */
    JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-call-compiled/n6/retR, _eREPLACEMENT_mcall_mcompiled__n6__retR, 0)

    /* Relocated code will jump to this label in non-relocated code. */
  JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
    JITTER_COMMENT_IN_ASM_("!REPLACEMENT-call-compiled/n6/retR non-relocatable code");
#endif // #ifdef JITTER_REPLICATE
#if defined(JITTER_DISPATCH_NO_THREADING)             \
    && (! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)  \
        || /* is this a replacement? */ 1)
  /* We use the implicit argument at the end of the calling.
     instruction to discover the procedure return address. */
  const void * const _jitter_return_pointer
    __attribute__ ((unused)) = JITTER_ARGP1;
  /* And make it accessible to the user (who will usually call 
     JITTER_BRANCH_AND_LINK) thru a nice macro. */
# define _JITTER_RETURN_ADDRESS _jitter_return_pointer
#endif

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of !REPLACEMENT-call-compiled/n6/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  no. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
//#if 0
  //fprintf (stderr, "Executing instruction %s..\n", "!REPLACEMENT-call-compiled/n6/retR"); fflush (stderr);
  //fprintf (stderr, "Executing replacement instruction %s..\n", "!REPLACEMENT-call-compiled/n6/retR"); fflush (stderr);
  //fprintf (stderr, "Executing non-relocatable instruction %s with JITTER_SPECIALIZED_INSTRUCTION_WORD_NO=%i..\n", "!REPLACEMENT-call-compiled/n6/retR", (int) JITTER_SPECIALIZED_INSTRUCTION_WORD_NO); fflush (stderr);
  //fprintf (stderr, "Executing caller replcament: _JITTER_RETURN_ADDRESS is %p..\n", _JITTER_RETURN_ADDRESS); fflush (stderr);
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#undef JITTER_THIS_IS_A_REPLACEMENT
#define JITTER_THIS_IS_A_REPLACEMENT 1

    /* User code for !REPLACEMENT-call-compiled/n6/retR . */
  {
/* User-specified code, user code block part: beginning. */

    const jitter_uint in_arity = JITTER_ARGN0;
    jitterlisp_object callee = JITTER_AT_DEPTH_MAINSTACK(in_arity);
    struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(callee);

    /* Here we can assume that * c is a compiled closure without checking. */
    struct jitterlisp_compiled_closure *cc = & c->compiled;

    /* Make place for the return address in the return stack.  The
       actual value will be written by the callee. */
    JITTER_PUSH_UNSPECIFIED_RETURNSTACK();
//    JITTER_TOP_RETURNSTACK() = 0x4242aaaa; // FIXME: just a test.  Remove.

    /* Branch-and-link to the native code, whose first instruction
       will be a prolog. */
    JITTER_BRANCH_AND_LINK(cc->first_program_point);
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for !REPLACEMENT-call-compiled/n6/retR . */

  //fprintf (stderr, "..Executed replacement instruction %s\n", "!REPLACEMENT-call-compiled/n6/retR");
  //fprintf (stderr, "..Executed instruction %s\n", "!REPLACEMENT-call-compiled/n6/retR");
//#endif // #if 0
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
#ifdef JITTER_REPLICATE
  {
    /* Advance the instruction pointer, if any, to skip every
       residual but the last; branch back to replicated
       code. */
    const void *_jitter_back_to_replicated_code_pointer =
      JITTER_ARGP1;
    JITTER_SKIP_RESIDUALS_;
    goto * _jitter_back_to_replicated_code_pointer;
  }
#endif // #ifdef JITTER_REPLICATE

    /* Undefine the !REPLACEMENT-call-compiled/n6/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#if    defined(JITTER_DISPATCH_NO_THREADING)         \
    && ! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)
# undef _JITTER_RETURN_ADDRESS
#endif

#ifndef JITTER_REPLICATE
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-call-compiled/n6/retR, _eREPLACEMENT_mcall_mcompiled__n6__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#endif // #ifndef JITTER_REPLICATE
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for !REPLACEMENT-call-compiled/n6/retR, which started with its
       definitions. */
  }
#endif // #if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
/*  End of !REPLACEMENT-call-compiled/n6/retR , a replacement specialised instruction */

  /* Ordinary specialised instruction !REPLACEMENT-call-compiled/n7/retR (replacement) */
  /* Omit this specialised instruction altogether unless
     replacements are in fact supported in this
     configuration. */
#if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
  JITTER_INSTRUCTION_PROLOG_(!REPLACEMENT-call-compiled/n7/retR, _eREPLACEMENT_mcall_mcompiled__n7__retR, cold)
  { /* This block begins with definitions for !REPLACEMENT-call-compiled/n7/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       253
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         !REPLACEMENT-call-compiled/n7/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "call-compiled"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "!REPLACEMENT-call-compiled/n7/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _eREPLACEMENT_mcall_mcompiled__n7__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement and a caller.
       Its 1-th argument, a literal, is the return address where to jump
       back after the procedure returns.  Branch-and-link
       functionality is enabled for this instruction. */
/* This instruction is non-relocatable: use branches which
   cannot ever generate defects. */
#   undef JITTER_BRANCH_AND_LINK
#   define JITTER_BRANCH_AND_LINK      _JITTER_BRANCH_AND_LINK_FALLBACK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   define JITTER_BRANCH_AND_LINK_WITH _JITTER_BRANCH_AND_LINK_WITH_FALLBACK
#   undef JITTER_BRANCH_FAST_AND_LINK
#   define JITTER_BRANCH_FAST_AND_LINK _JITTER_BRANCH_AND_LINK_FALLBACK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1

    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 7L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1


#ifdef JITTER_REPLICATE
/* When jumping to the non-relocatable part it is important not
   to use a fallback version of JITTER_COMPUTED_GOTO, in order to
   prevent GCC from tail-merging. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
    /* Jump to non-relocatable code. */
    JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);

    /* Here the residual arity is given as zero: it's too late to
       skip residuals, since we've already jumped and this code is
       unreachable.  The instruction pointer, if any, is advanced
       in the non-relocatable code. */
    JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-call-compiled/n7/retR, _eREPLACEMENT_mcall_mcompiled__n7__retR, 0)

    /* Relocated code will jump to this label in non-relocated code. */
  JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
    JITTER_COMMENT_IN_ASM_("!REPLACEMENT-call-compiled/n7/retR non-relocatable code");
#endif // #ifdef JITTER_REPLICATE
#if defined(JITTER_DISPATCH_NO_THREADING)             \
    && (! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)  \
        || /* is this a replacement? */ 1)
  /* We use the implicit argument at the end of the calling.
     instruction to discover the procedure return address. */
  const void * const _jitter_return_pointer
    __attribute__ ((unused)) = JITTER_ARGP1;
  /* And make it accessible to the user (who will usually call 
     JITTER_BRANCH_AND_LINK) thru a nice macro. */
# define _JITTER_RETURN_ADDRESS _jitter_return_pointer
#endif

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of !REPLACEMENT-call-compiled/n7/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  no. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
//#if 0
  //fprintf (stderr, "Executing instruction %s..\n", "!REPLACEMENT-call-compiled/n7/retR"); fflush (stderr);
  //fprintf (stderr, "Executing replacement instruction %s..\n", "!REPLACEMENT-call-compiled/n7/retR"); fflush (stderr);
  //fprintf (stderr, "Executing non-relocatable instruction %s with JITTER_SPECIALIZED_INSTRUCTION_WORD_NO=%i..\n", "!REPLACEMENT-call-compiled/n7/retR", (int) JITTER_SPECIALIZED_INSTRUCTION_WORD_NO); fflush (stderr);
  //fprintf (stderr, "Executing caller replcament: _JITTER_RETURN_ADDRESS is %p..\n", _JITTER_RETURN_ADDRESS); fflush (stderr);
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#undef JITTER_THIS_IS_A_REPLACEMENT
#define JITTER_THIS_IS_A_REPLACEMENT 1

    /* User code for !REPLACEMENT-call-compiled/n7/retR . */
  {
/* User-specified code, user code block part: beginning. */

    const jitter_uint in_arity = JITTER_ARGN0;
    jitterlisp_object callee = JITTER_AT_DEPTH_MAINSTACK(in_arity);
    struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(callee);

    /* Here we can assume that * c is a compiled closure without checking. */
    struct jitterlisp_compiled_closure *cc = & c->compiled;

    /* Make place for the return address in the return stack.  The
       actual value will be written by the callee. */
    JITTER_PUSH_UNSPECIFIED_RETURNSTACK();
//    JITTER_TOP_RETURNSTACK() = 0x4242aaaa; // FIXME: just a test.  Remove.

    /* Branch-and-link to the native code, whose first instruction
       will be a prolog. */
    JITTER_BRANCH_AND_LINK(cc->first_program_point);
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for !REPLACEMENT-call-compiled/n7/retR . */

  //fprintf (stderr, "..Executed replacement instruction %s\n", "!REPLACEMENT-call-compiled/n7/retR");
  //fprintf (stderr, "..Executed instruction %s\n", "!REPLACEMENT-call-compiled/n7/retR");
//#endif // #if 0
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
#ifdef JITTER_REPLICATE
  {
    /* Advance the instruction pointer, if any, to skip every
       residual but the last; branch back to replicated
       code. */
    const void *_jitter_back_to_replicated_code_pointer =
      JITTER_ARGP1;
    JITTER_SKIP_RESIDUALS_;
    goto * _jitter_back_to_replicated_code_pointer;
  }
#endif // #ifdef JITTER_REPLICATE

    /* Undefine the !REPLACEMENT-call-compiled/n7/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#if    defined(JITTER_DISPATCH_NO_THREADING)         \
    && ! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)
# undef _JITTER_RETURN_ADDRESS
#endif

#ifndef JITTER_REPLICATE
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-call-compiled/n7/retR, _eREPLACEMENT_mcall_mcompiled__n7__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#endif // #ifndef JITTER_REPLICATE
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for !REPLACEMENT-call-compiled/n7/retR, which started with its
       definitions. */
  }
#endif // #if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
/*  End of !REPLACEMENT-call-compiled/n7/retR , a replacement specialised instruction */

  /* Ordinary specialised instruction !REPLACEMENT-call-compiled/n8/retR (replacement) */
  /* Omit this specialised instruction altogether unless
     replacements are in fact supported in this
     configuration. */
#if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
  JITTER_INSTRUCTION_PROLOG_(!REPLACEMENT-call-compiled/n8/retR, _eREPLACEMENT_mcall_mcompiled__n8__retR, cold)
  { /* This block begins with definitions for !REPLACEMENT-call-compiled/n8/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       254
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         !REPLACEMENT-call-compiled/n8/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "call-compiled"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "!REPLACEMENT-call-compiled/n8/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _eREPLACEMENT_mcall_mcompiled__n8__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement and a caller.
       Its 1-th argument, a literal, is the return address where to jump
       back after the procedure returns.  Branch-and-link
       functionality is enabled for this instruction. */
/* This instruction is non-relocatable: use branches which
   cannot ever generate defects. */
#   undef JITTER_BRANCH_AND_LINK
#   define JITTER_BRANCH_AND_LINK      _JITTER_BRANCH_AND_LINK_FALLBACK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   define JITTER_BRANCH_AND_LINK_WITH _JITTER_BRANCH_AND_LINK_WITH_FALLBACK
#   undef JITTER_BRANCH_FAST_AND_LINK
#   define JITTER_BRANCH_FAST_AND_LINK _JITTER_BRANCH_AND_LINK_FALLBACK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1

    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 8L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1


#ifdef JITTER_REPLICATE
/* When jumping to the non-relocatable part it is important not
   to use a fallback version of JITTER_COMPUTED_GOTO, in order to
   prevent GCC from tail-merging. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
    /* Jump to non-relocatable code. */
    JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);

    /* Here the residual arity is given as zero: it's too late to
       skip residuals, since we've already jumped and this code is
       unreachable.  The instruction pointer, if any, is advanced
       in the non-relocatable code. */
    JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-call-compiled/n8/retR, _eREPLACEMENT_mcall_mcompiled__n8__retR, 0)

    /* Relocated code will jump to this label in non-relocated code. */
  JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
    JITTER_COMMENT_IN_ASM_("!REPLACEMENT-call-compiled/n8/retR non-relocatable code");
#endif // #ifdef JITTER_REPLICATE
#if defined(JITTER_DISPATCH_NO_THREADING)             \
    && (! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)  \
        || /* is this a replacement? */ 1)
  /* We use the implicit argument at the end of the calling.
     instruction to discover the procedure return address. */
  const void * const _jitter_return_pointer
    __attribute__ ((unused)) = JITTER_ARGP1;
  /* And make it accessible to the user (who will usually call 
     JITTER_BRANCH_AND_LINK) thru a nice macro. */
# define _JITTER_RETURN_ADDRESS _jitter_return_pointer
#endif

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of !REPLACEMENT-call-compiled/n8/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  no. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
//#if 0
  //fprintf (stderr, "Executing instruction %s..\n", "!REPLACEMENT-call-compiled/n8/retR"); fflush (stderr);
  //fprintf (stderr, "Executing replacement instruction %s..\n", "!REPLACEMENT-call-compiled/n8/retR"); fflush (stderr);
  //fprintf (stderr, "Executing non-relocatable instruction %s with JITTER_SPECIALIZED_INSTRUCTION_WORD_NO=%i..\n", "!REPLACEMENT-call-compiled/n8/retR", (int) JITTER_SPECIALIZED_INSTRUCTION_WORD_NO); fflush (stderr);
  //fprintf (stderr, "Executing caller replcament: _JITTER_RETURN_ADDRESS is %p..\n", _JITTER_RETURN_ADDRESS); fflush (stderr);
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#undef JITTER_THIS_IS_A_REPLACEMENT
#define JITTER_THIS_IS_A_REPLACEMENT 1

    /* User code for !REPLACEMENT-call-compiled/n8/retR . */
  {
/* User-specified code, user code block part: beginning. */

    const jitter_uint in_arity = JITTER_ARGN0;
    jitterlisp_object callee = JITTER_AT_DEPTH_MAINSTACK(in_arity);
    struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(callee);

    /* Here we can assume that * c is a compiled closure without checking. */
    struct jitterlisp_compiled_closure *cc = & c->compiled;

    /* Make place for the return address in the return stack.  The
       actual value will be written by the callee. */
    JITTER_PUSH_UNSPECIFIED_RETURNSTACK();
//    JITTER_TOP_RETURNSTACK() = 0x4242aaaa; // FIXME: just a test.  Remove.

    /* Branch-and-link to the native code, whose first instruction
       will be a prolog. */
    JITTER_BRANCH_AND_LINK(cc->first_program_point);
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for !REPLACEMENT-call-compiled/n8/retR . */

  //fprintf (stderr, "..Executed replacement instruction %s\n", "!REPLACEMENT-call-compiled/n8/retR");
  //fprintf (stderr, "..Executed instruction %s\n", "!REPLACEMENT-call-compiled/n8/retR");
//#endif // #if 0
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
#ifdef JITTER_REPLICATE
  {
    /* Advance the instruction pointer, if any, to skip every
       residual but the last; branch back to replicated
       code. */
    const void *_jitter_back_to_replicated_code_pointer =
      JITTER_ARGP1;
    JITTER_SKIP_RESIDUALS_;
    goto * _jitter_back_to_replicated_code_pointer;
  }
#endif // #ifdef JITTER_REPLICATE

    /* Undefine the !REPLACEMENT-call-compiled/n8/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#if    defined(JITTER_DISPATCH_NO_THREADING)         \
    && ! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)
# undef _JITTER_RETURN_ADDRESS
#endif

#ifndef JITTER_REPLICATE
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-call-compiled/n8/retR, _eREPLACEMENT_mcall_mcompiled__n8__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#endif // #ifndef JITTER_REPLICATE
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for !REPLACEMENT-call-compiled/n8/retR, which started with its
       definitions. */
  }
#endif // #if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
/*  End of !REPLACEMENT-call-compiled/n8/retR , a replacement specialised instruction */

  /* Ordinary specialised instruction !REPLACEMENT-call-compiled/n9/retR (replacement) */
  /* Omit this specialised instruction altogether unless
     replacements are in fact supported in this
     configuration. */
#if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
  JITTER_INSTRUCTION_PROLOG_(!REPLACEMENT-call-compiled/n9/retR, _eREPLACEMENT_mcall_mcompiled__n9__retR, cold)
  { /* This block begins with definitions for !REPLACEMENT-call-compiled/n9/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       255
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         !REPLACEMENT-call-compiled/n9/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "call-compiled"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "!REPLACEMENT-call-compiled/n9/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _eREPLACEMENT_mcall_mcompiled__n9__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement and a caller.
       Its 1-th argument, a literal, is the return address where to jump
       back after the procedure returns.  Branch-and-link
       functionality is enabled for this instruction. */
/* This instruction is non-relocatable: use branches which
   cannot ever generate defects. */
#   undef JITTER_BRANCH_AND_LINK
#   define JITTER_BRANCH_AND_LINK      _JITTER_BRANCH_AND_LINK_FALLBACK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   define JITTER_BRANCH_AND_LINK_WITH _JITTER_BRANCH_AND_LINK_WITH_FALLBACK
#   undef JITTER_BRANCH_FAST_AND_LINK
#   define JITTER_BRANCH_FAST_AND_LINK _JITTER_BRANCH_AND_LINK_FALLBACK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1

    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 9L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1


#ifdef JITTER_REPLICATE
/* When jumping to the non-relocatable part it is important not
   to use a fallback version of JITTER_COMPUTED_GOTO, in order to
   prevent GCC from tail-merging. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
    /* Jump to non-relocatable code. */
    JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);

    /* Here the residual arity is given as zero: it's too late to
       skip residuals, since we've already jumped and this code is
       unreachable.  The instruction pointer, if any, is advanced
       in the non-relocatable code. */
    JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-call-compiled/n9/retR, _eREPLACEMENT_mcall_mcompiled__n9__retR, 0)

    /* Relocated code will jump to this label in non-relocated code. */
  JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
    JITTER_COMMENT_IN_ASM_("!REPLACEMENT-call-compiled/n9/retR non-relocatable code");
#endif // #ifdef JITTER_REPLICATE
#if defined(JITTER_DISPATCH_NO_THREADING)             \
    && (! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)  \
        || /* is this a replacement? */ 1)
  /* We use the implicit argument at the end of the calling.
     instruction to discover the procedure return address. */
  const void * const _jitter_return_pointer
    __attribute__ ((unused)) = JITTER_ARGP1;
  /* And make it accessible to the user (who will usually call 
     JITTER_BRANCH_AND_LINK) thru a nice macro. */
# define _JITTER_RETURN_ADDRESS _jitter_return_pointer
#endif

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of !REPLACEMENT-call-compiled/n9/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  no. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
//#if 0
  //fprintf (stderr, "Executing instruction %s..\n", "!REPLACEMENT-call-compiled/n9/retR"); fflush (stderr);
  //fprintf (stderr, "Executing replacement instruction %s..\n", "!REPLACEMENT-call-compiled/n9/retR"); fflush (stderr);
  //fprintf (stderr, "Executing non-relocatable instruction %s with JITTER_SPECIALIZED_INSTRUCTION_WORD_NO=%i..\n", "!REPLACEMENT-call-compiled/n9/retR", (int) JITTER_SPECIALIZED_INSTRUCTION_WORD_NO); fflush (stderr);
  //fprintf (stderr, "Executing caller replcament: _JITTER_RETURN_ADDRESS is %p..\n", _JITTER_RETURN_ADDRESS); fflush (stderr);
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#undef JITTER_THIS_IS_A_REPLACEMENT
#define JITTER_THIS_IS_A_REPLACEMENT 1

    /* User code for !REPLACEMENT-call-compiled/n9/retR . */
  {
/* User-specified code, user code block part: beginning. */

    const jitter_uint in_arity = JITTER_ARGN0;
    jitterlisp_object callee = JITTER_AT_DEPTH_MAINSTACK(in_arity);
    struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(callee);

    /* Here we can assume that * c is a compiled closure without checking. */
    struct jitterlisp_compiled_closure *cc = & c->compiled;

    /* Make place for the return address in the return stack.  The
       actual value will be written by the callee. */
    JITTER_PUSH_UNSPECIFIED_RETURNSTACK();
//    JITTER_TOP_RETURNSTACK() = 0x4242aaaa; // FIXME: just a test.  Remove.

    /* Branch-and-link to the native code, whose first instruction
       will be a prolog. */
    JITTER_BRANCH_AND_LINK(cc->first_program_point);
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for !REPLACEMENT-call-compiled/n9/retR . */

  //fprintf (stderr, "..Executed replacement instruction %s\n", "!REPLACEMENT-call-compiled/n9/retR");
  //fprintf (stderr, "..Executed instruction %s\n", "!REPLACEMENT-call-compiled/n9/retR");
//#endif // #if 0
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
#ifdef JITTER_REPLICATE
  {
    /* Advance the instruction pointer, if any, to skip every
       residual but the last; branch back to replicated
       code. */
    const void *_jitter_back_to_replicated_code_pointer =
      JITTER_ARGP1;
    JITTER_SKIP_RESIDUALS_;
    goto * _jitter_back_to_replicated_code_pointer;
  }
#endif // #ifdef JITTER_REPLICATE

    /* Undefine the !REPLACEMENT-call-compiled/n9/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#if    defined(JITTER_DISPATCH_NO_THREADING)         \
    && ! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)
# undef _JITTER_RETURN_ADDRESS
#endif

#ifndef JITTER_REPLICATE
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-call-compiled/n9/retR, _eREPLACEMENT_mcall_mcompiled__n9__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#endif // #ifndef JITTER_REPLICATE
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for !REPLACEMENT-call-compiled/n9/retR, which started with its
       definitions. */
  }
#endif // #if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
/*  End of !REPLACEMENT-call-compiled/n9/retR , a replacement specialised instruction */

  /* Ordinary specialised instruction !REPLACEMENT-call-compiled/n10/retR (replacement) */
  /* Omit this specialised instruction altogether unless
     replacements are in fact supported in this
     configuration. */
#if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
  JITTER_INSTRUCTION_PROLOG_(!REPLACEMENT-call-compiled/n10/retR, _eREPLACEMENT_mcall_mcompiled__n10__retR, cold)
  { /* This block begins with definitions for !REPLACEMENT-call-compiled/n10/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       256
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         !REPLACEMENT-call-compiled/n10/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "call-compiled"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "!REPLACEMENT-call-compiled/n10/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _eREPLACEMENT_mcall_mcompiled__n10__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement and a caller.
       Its 1-th argument, a literal, is the return address where to jump
       back after the procedure returns.  Branch-and-link
       functionality is enabled for this instruction. */
/* This instruction is non-relocatable: use branches which
   cannot ever generate defects. */
#   undef JITTER_BRANCH_AND_LINK
#   define JITTER_BRANCH_AND_LINK      _JITTER_BRANCH_AND_LINK_FALLBACK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   define JITTER_BRANCH_AND_LINK_WITH _JITTER_BRANCH_AND_LINK_WITH_FALLBACK
#   undef JITTER_BRANCH_FAST_AND_LINK
#   define JITTER_BRANCH_FAST_AND_LINK _JITTER_BRANCH_AND_LINK_FALLBACK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1

    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 10L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1


#ifdef JITTER_REPLICATE
/* When jumping to the non-relocatable part it is important not
   to use a fallback version of JITTER_COMPUTED_GOTO, in order to
   prevent GCC from tail-merging. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
    /* Jump to non-relocatable code. */
    JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);

    /* Here the residual arity is given as zero: it's too late to
       skip residuals, since we've already jumped and this code is
       unreachable.  The instruction pointer, if any, is advanced
       in the non-relocatable code. */
    JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-call-compiled/n10/retR, _eREPLACEMENT_mcall_mcompiled__n10__retR, 0)

    /* Relocated code will jump to this label in non-relocated code. */
  JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
    JITTER_COMMENT_IN_ASM_("!REPLACEMENT-call-compiled/n10/retR non-relocatable code");
#endif // #ifdef JITTER_REPLICATE
#if defined(JITTER_DISPATCH_NO_THREADING)             \
    && (! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)  \
        || /* is this a replacement? */ 1)
  /* We use the implicit argument at the end of the calling.
     instruction to discover the procedure return address. */
  const void * const _jitter_return_pointer
    __attribute__ ((unused)) = JITTER_ARGP1;
  /* And make it accessible to the user (who will usually call 
     JITTER_BRANCH_AND_LINK) thru a nice macro. */
# define _JITTER_RETURN_ADDRESS _jitter_return_pointer
#endif

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of !REPLACEMENT-call-compiled/n10/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  no. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
//#if 0
  //fprintf (stderr, "Executing instruction %s..\n", "!REPLACEMENT-call-compiled/n10/retR"); fflush (stderr);
  //fprintf (stderr, "Executing replacement instruction %s..\n", "!REPLACEMENT-call-compiled/n10/retR"); fflush (stderr);
  //fprintf (stderr, "Executing non-relocatable instruction %s with JITTER_SPECIALIZED_INSTRUCTION_WORD_NO=%i..\n", "!REPLACEMENT-call-compiled/n10/retR", (int) JITTER_SPECIALIZED_INSTRUCTION_WORD_NO); fflush (stderr);
  //fprintf (stderr, "Executing caller replcament: _JITTER_RETURN_ADDRESS is %p..\n", _JITTER_RETURN_ADDRESS); fflush (stderr);
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#undef JITTER_THIS_IS_A_REPLACEMENT
#define JITTER_THIS_IS_A_REPLACEMENT 1

    /* User code for !REPLACEMENT-call-compiled/n10/retR . */
  {
/* User-specified code, user code block part: beginning. */

    const jitter_uint in_arity = JITTER_ARGN0;
    jitterlisp_object callee = JITTER_AT_DEPTH_MAINSTACK(in_arity);
    struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(callee);

    /* Here we can assume that * c is a compiled closure without checking. */
    struct jitterlisp_compiled_closure *cc = & c->compiled;

    /* Make place for the return address in the return stack.  The
       actual value will be written by the callee. */
    JITTER_PUSH_UNSPECIFIED_RETURNSTACK();
//    JITTER_TOP_RETURNSTACK() = 0x4242aaaa; // FIXME: just a test.  Remove.

    /* Branch-and-link to the native code, whose first instruction
       will be a prolog. */
    JITTER_BRANCH_AND_LINK(cc->first_program_point);
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for !REPLACEMENT-call-compiled/n10/retR . */

  //fprintf (stderr, "..Executed replacement instruction %s\n", "!REPLACEMENT-call-compiled/n10/retR");
  //fprintf (stderr, "..Executed instruction %s\n", "!REPLACEMENT-call-compiled/n10/retR");
//#endif // #if 0
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
#ifdef JITTER_REPLICATE
  {
    /* Advance the instruction pointer, if any, to skip every
       residual but the last; branch back to replicated
       code. */
    const void *_jitter_back_to_replicated_code_pointer =
      JITTER_ARGP1;
    JITTER_SKIP_RESIDUALS_;
    goto * _jitter_back_to_replicated_code_pointer;
  }
#endif // #ifdef JITTER_REPLICATE

    /* Undefine the !REPLACEMENT-call-compiled/n10/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#if    defined(JITTER_DISPATCH_NO_THREADING)         \
    && ! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)
# undef _JITTER_RETURN_ADDRESS
#endif

#ifndef JITTER_REPLICATE
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-call-compiled/n10/retR, _eREPLACEMENT_mcall_mcompiled__n10__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#endif // #ifndef JITTER_REPLICATE
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for !REPLACEMENT-call-compiled/n10/retR, which started with its
       definitions. */
  }
#endif // #if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
/*  End of !REPLACEMENT-call-compiled/n10/retR , a replacement specialised instruction */

  /* Ordinary specialised instruction !REPLACEMENT-call-compiled/nR/retR (replacement) */
  /* Omit this specialised instruction altogether unless
     replacements are in fact supported in this
     configuration. */
#if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
  JITTER_INSTRUCTION_PROLOG_(!REPLACEMENT-call-compiled/nR/retR, _eREPLACEMENT_mcall_mcompiled__nR__retR, cold)
  { /* This block begins with definitions for !REPLACEMENT-call-compiled/nR/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       257
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         !REPLACEMENT-call-compiled/nR/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "call-compiled"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "!REPLACEMENT-call-compiled/nR/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _eREPLACEMENT_mcall_mcompiled__nR__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement and a caller.
       Its 1-th argument, a literal, is the return address where to jump
       back after the procedure returns.  Branch-and-link
       functionality is enabled for this instruction. */
/* This instruction is non-relocatable: use branches which
   cannot ever generate defects. */
#   undef JITTER_BRANCH_AND_LINK
#   define JITTER_BRANCH_AND_LINK      _JITTER_BRANCH_AND_LINK_FALLBACK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   define JITTER_BRANCH_AND_LINK_WITH _JITTER_BRANCH_AND_LINK_WITH_FALLBACK
#   undef JITTER_BRANCH_FAST_AND_LINK
#   define JITTER_BRANCH_FAST_AND_LINK _JITTER_BRANCH_AND_LINK_FALLBACK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 2

    /* The 0th argument is a residual literal. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1


#ifdef JITTER_REPLICATE
/* When jumping to the non-relocatable part it is important not
   to use a fallback version of JITTER_COMPUTED_GOTO, in order to
   prevent GCC from tail-merging. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
    /* Jump to non-relocatable code. */
    JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);

    /* Here the residual arity is given as zero: it's too late to
       skip residuals, since we've already jumped and this code is
       unreachable.  The instruction pointer, if any, is advanced
       in the non-relocatable code. */
    JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-call-compiled/nR/retR, _eREPLACEMENT_mcall_mcompiled__nR__retR, 0)

    /* Relocated code will jump to this label in non-relocated code. */
  JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
    JITTER_COMMENT_IN_ASM_("!REPLACEMENT-call-compiled/nR/retR non-relocatable code");
#endif // #ifdef JITTER_REPLICATE
#if defined(JITTER_DISPATCH_NO_THREADING)             \
    && (! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)  \
        || /* is this a replacement? */ 1)
  /* We use the implicit argument at the end of the calling.
     instruction to discover the procedure return address. */
  const void * const _jitter_return_pointer
    __attribute__ ((unused)) = JITTER_ARGP1;
  /* And make it accessible to the user (who will usually call 
     JITTER_BRANCH_AND_LINK) thru a nice macro. */
# define _JITTER_RETURN_ADDRESS _jitter_return_pointer
#endif

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of !REPLACEMENT-call-compiled/nR/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  no. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
//#if 0
  //fprintf (stderr, "Executing instruction %s..\n", "!REPLACEMENT-call-compiled/nR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing replacement instruction %s..\n", "!REPLACEMENT-call-compiled/nR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing non-relocatable instruction %s with JITTER_SPECIALIZED_INSTRUCTION_WORD_NO=%i..\n", "!REPLACEMENT-call-compiled/nR/retR", (int) JITTER_SPECIALIZED_INSTRUCTION_WORD_NO); fflush (stderr);
  //fprintf (stderr, "Executing caller replcament: _JITTER_RETURN_ADDRESS is %p..\n", _JITTER_RETURN_ADDRESS); fflush (stderr);
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#undef JITTER_THIS_IS_A_REPLACEMENT
#define JITTER_THIS_IS_A_REPLACEMENT 1

    /* User code for !REPLACEMENT-call-compiled/nR/retR . */
  {
/* User-specified code, user code block part: beginning. */

    const jitter_uint in_arity = JITTER_ARGN0;
    jitterlisp_object callee = JITTER_AT_DEPTH_MAINSTACK(in_arity);
    struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(callee);

    /* Here we can assume that * c is a compiled closure without checking. */
    struct jitterlisp_compiled_closure *cc = & c->compiled;

    /* Make place for the return address in the return stack.  The
       actual value will be written by the callee. */
    JITTER_PUSH_UNSPECIFIED_RETURNSTACK();
//    JITTER_TOP_RETURNSTACK() = 0x4242aaaa; // FIXME: just a test.  Remove.

    /* Branch-and-link to the native code, whose first instruction
       will be a prolog. */
    JITTER_BRANCH_AND_LINK(cc->first_program_point);
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for !REPLACEMENT-call-compiled/nR/retR . */

  //fprintf (stderr, "..Executed replacement instruction %s\n", "!REPLACEMENT-call-compiled/nR/retR");
  //fprintf (stderr, "..Executed instruction %s\n", "!REPLACEMENT-call-compiled/nR/retR");
//#endif // #if 0
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
#ifdef JITTER_REPLICATE
  {
    /* Advance the instruction pointer, if any, to skip every
       residual but the last; branch back to replicated
       code. */
    const void *_jitter_back_to_replicated_code_pointer =
      JITTER_ARGP1;
    JITTER_SKIP_RESIDUALS_;
    goto * _jitter_back_to_replicated_code_pointer;
  }
#endif // #ifdef JITTER_REPLICATE

    /* Undefine the !REPLACEMENT-call-compiled/nR/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#if    defined(JITTER_DISPATCH_NO_THREADING)         \
    && ! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)
# undef _JITTER_RETURN_ADDRESS
#endif

#ifndef JITTER_REPLICATE
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-call-compiled/nR/retR, _eREPLACEMENT_mcall_mcompiled__nR__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#endif // #ifndef JITTER_REPLICATE
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for !REPLACEMENT-call-compiled/nR/retR, which started with its
       definitions. */
  }
#endif // #if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
/*  End of !REPLACEMENT-call-compiled/nR/retR , a replacement specialised instruction */

  /* Ordinary specialised instruction !REPLACEMENT-call-from-c/retR (replacement) */
  /* Omit this specialised instruction altogether unless
     replacements are in fact supported in this
     configuration. */
#if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
  JITTER_INSTRUCTION_PROLOG_(!REPLACEMENT-call-from-c/retR, _eREPLACEMENT_mcall_mfrom_mc__retR, cold)
  { /* This block begins with definitions for !REPLACEMENT-call-from-c/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       258
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         !REPLACEMENT-call-from-c/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "call-from-c"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "!REPLACEMENT-call-from-c/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _eREPLACEMENT_mcall_mfrom_mc__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is non-relocatable.
       Its 0-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is non-relocatable.
       Its 0-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement and a caller.
       Its 0-th argument, a literal, is the return address where to jump
       back after the procedure returns.  Branch-and-link
       functionality is enabled for this instruction. */
/* This instruction is non-relocatable: use branches which
   cannot ever generate defects. */
#   undef JITTER_BRANCH_AND_LINK
#   define JITTER_BRANCH_AND_LINK      _JITTER_BRANCH_AND_LINK_FALLBACK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   define JITTER_BRANCH_AND_LINK_WITH _JITTER_BRANCH_AND_LINK_WITH_FALLBACK
#   undef JITTER_BRANCH_FAST_AND_LINK
#   define JITTER_BRANCH_FAST_AND_LINK _JITTER_BRANCH_AND_LINK_FALLBACK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1

    /* The 0th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0


#ifdef JITTER_REPLICATE
/* When jumping to the non-relocatable part it is important not
   to use a fallback version of JITTER_COMPUTED_GOTO, in order to
   prevent GCC from tail-merging. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
    /* Jump to non-relocatable code. */
    JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);

    /* Here the residual arity is given as zero: it's too late to
       skip residuals, since we've already jumped and this code is
       unreachable.  The instruction pointer, if any, is advanced
       in the non-relocatable code. */
    JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-call-from-c/retR, _eREPLACEMENT_mcall_mfrom_mc__retR, 0)

    /* Relocated code will jump to this label in non-relocated code. */
  JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
    JITTER_COMMENT_IN_ASM_("!REPLACEMENT-call-from-c/retR non-relocatable code");
#endif // #ifdef JITTER_REPLICATE
#if defined(JITTER_DISPATCH_NO_THREADING)             \
    && (! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)  \
        || /* is this a replacement? */ 1)
  /* We use the implicit argument at the end of the calling.
     instruction to discover the procedure return address. */
  const void * const _jitter_return_pointer
    __attribute__ ((unused)) = JITTER_ARGP0;
  /* And make it accessible to the user (who will usually call 
     JITTER_BRANCH_AND_LINK) thru a nice macro. */
# define _JITTER_RETURN_ADDRESS _jitter_return_pointer
#endif

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of !REPLACEMENT-call-from-c/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  no. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
//#if 0
  //fprintf (stderr, "Executing instruction %s..\n", "!REPLACEMENT-call-from-c/retR"); fflush (stderr);
  //fprintf (stderr, "Executing replacement instruction %s..\n", "!REPLACEMENT-call-from-c/retR"); fflush (stderr);
  //fprintf (stderr, "Executing non-relocatable instruction %s with JITTER_SPECIALIZED_INSTRUCTION_WORD_NO=%i..\n", "!REPLACEMENT-call-from-c/retR", (int) JITTER_SPECIALIZED_INSTRUCTION_WORD_NO); fflush (stderr);
  //fprintf (stderr, "Executing caller replcament: _JITTER_RETURN_ADDRESS is %p..\n", _JITTER_RETURN_ADDRESS); fflush (stderr);
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#undef JITTER_THIS_IS_A_REPLACEMENT
#define JITTER_THIS_IS_A_REPLACEMENT 1

    /* User code for !REPLACEMENT-call-from-c/retR . */
  {
/* User-specified code, user code block part: beginning. */

    /* Get a number (untagged) from the stack top, so that I know at which
       depth to find the closure.  The arity check must have been
       performed already on the interpreter side. */
    const jitter_uint in_arity_plus_one = JITTER_TOP_MAINSTACK();

    /* What follows is similar to the call instruction in the case of a compiled
       callee.  Shall I factor the common code with a macro? */

    /* Decode the closure. */
    jitterlisp_object callee
      = JITTER_AT_NONZERO_DEPTH_MAINSTACK(in_arity_plus_one);
    struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(callee);
    struct jitterlisp_compiled_closure *cc = & c->compiled;

    /* Drop the number of arguments. */
    JITTER_DROP_MAINSTACK();

    /* Make place for the return address in the return stack.  The
       actual value will be written by the callee. */
    JITTER_PUSH_UNSPECIFIED_RETURNSTACK();

    /* Branch-and-link.  This follows the ordinary calling convention,
       with the main stack containing the closure and its actuals, known
       to be in the correct number.  The next VM instruction will be a
       prolog saving the link; then execution will fall thru into the
       compiled closure body. */
    JITTER_BRANCH_AND_LINK(cc->first_program_point);
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for !REPLACEMENT-call-from-c/retR . */

  //fprintf (stderr, "..Executed replacement instruction %s\n", "!REPLACEMENT-call-from-c/retR");
  //fprintf (stderr, "..Executed instruction %s\n", "!REPLACEMENT-call-from-c/retR");
//#endif // #if 0
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
#ifdef JITTER_REPLICATE
  {
    /* Advance the instruction pointer, if any, to skip every
       residual but the last; branch back to replicated
       code. */
    const void *_jitter_back_to_replicated_code_pointer =
      JITTER_ARGP0;
    JITTER_SKIP_RESIDUALS_;
    goto * _jitter_back_to_replicated_code_pointer;
  }
#endif // #ifdef JITTER_REPLICATE

    /* Undefine the !REPLACEMENT-call-from-c/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#if    defined(JITTER_DISPATCH_NO_THREADING)         \
    && ! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)
# undef _JITTER_RETURN_ADDRESS
#endif

#ifndef JITTER_REPLICATE
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-call-from-c/retR, _eREPLACEMENT_mcall_mfrom_mc__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#endif // #ifndef JITTER_REPLICATE
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for !REPLACEMENT-call-from-c/retR, which started with its
       definitions. */
  }
#endif // #if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
/*  End of !REPLACEMENT-call-from-c/retR , a replacement specialised instruction */

  /* Ordinary specialised instruction !REPLACEMENT-cdr-register/%rR/%rR/fR/retR (replacement) */
  /* Omit this specialised instruction altogether unless
     replacements are in fact supported in this
     configuration. */
#if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
  JITTER_INSTRUCTION_PROLOG_(!REPLACEMENT-cdr-register/%rR/%rR/fR/retR, _eREPLACEMENT_mcdr_mregister___rrR___rrR__fR__retR, cold)
  { /* This block begins with definitions for !REPLACEMENT-cdr-register/%rR/%rR/fR/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       259
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         !REPLACEMENT-cdr-register/%rR/%rR/fR/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "cdr-register"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "!REPLACEMENT-cdr-register/%rR/%rR/fR/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _eREPLACEMENT_mcdr_mregister___rrR___rrR__fR__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is non-relocatable.
       Its 3-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST JITTER_BRANCH
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
    /* This specialized instruction is non-relocatable.
       Its 3-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 4

  /* Define argument-access macros for !REPLACEMENT-cdr-register/%rR/%rR/fR/retR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a slow (therefore residual, passed as an offset)
        register. */
  /* Define a macro expanding to the slow register offset. */
#if defined(JITTER_DISPATCH_NO_THREADING)
# define JITTER_SLOW_REGISTER_OFFSET0 (JITTER_RESIDUAL_ARGUMENT_0.fixnum)
#elif defined (JITTER_DISPATCH_MINIMAL_THREADING)
# define JITTER_SLOW_REGISTER_OFFSET0 ((((union jitter_word*)jitter_ip)[0]).fixnum)
#else
# define JITTER_SLOW_REGISTER_OFFSET0 ((((union jitter_word*)jitter_ip)[1]).fixnum)
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
  /* Define a macro expanding to an l-value for the VM register content. */
#   define JITTER_ARG0  JITTER_SLOW_REGISTER_FROM_OFFSET(r, JITTER_SLOW_REGISTER_OFFSET0)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)

    /* The 1th argument is a slow (therefore residual, passed as an offset)
        register. */
  /* Define a macro expanding to the slow register offset. */
#if defined(JITTER_DISPATCH_NO_THREADING)
# define JITTER_SLOW_REGISTER_OFFSET1 (JITTER_RESIDUAL_ARGUMENT_1.fixnum)
#elif defined (JITTER_DISPATCH_MINIMAL_THREADING)
# define JITTER_SLOW_REGISTER_OFFSET1 ((((union jitter_word*)jitter_ip)[1]).fixnum)
#else
# define JITTER_SLOW_REGISTER_OFFSET1 ((((union jitter_word*)jitter_ip)[2]).fixnum)
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
  /* Define a macro expanding to an l-value for the VM register content. */
#   define JITTER_ARG1  JITTER_SLOW_REGISTER_FROM_OFFSET(r, JITTER_SLOW_REGISTER_OFFSET1)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)

    /* The 2th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG2  JITTER_RESIDUAL_ARGUMENT_2
    JITTER_MARK_RESIDUAL_2_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[2])
#else
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[3])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN2 (JITTER_ARG2.fixnum)
#   define JITTER_ARGU2 (JITTER_ARG2.ufixnum)
#   define JITTER_ARGP2 (JITTER_ARG2.pointer)
#   define JITTER_ARGF2 JITTER_ARGP2

    /* The 3th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG3  JITTER_RESIDUAL_ARGUMENT_3
    JITTER_MARK_RESIDUAL_3_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG3  (((union jitter_word*)jitter_ip)[3])
#else
#   define JITTER_ARG3  (((union jitter_word*)jitter_ip)[4])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN3 (JITTER_ARG3.fixnum)
#   define JITTER_ARGU3 (JITTER_ARG3.ufixnum)
#   define JITTER_ARGP3 (JITTER_ARG3.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
    /* The 0th argument is a slow (therefore residual, passed as an offset)
        register. */
  /* Define a macro expanding to the slow register offset. */
#if defined(JITTER_DISPATCH_NO_THREADING)
# define JITTER_SLOW_REGISTER_OFFSET0 (JITTER_RESIDUAL_ARGUMENT_0.fixnum)
#elif defined (JITTER_DISPATCH_MINIMAL_THREADING)
# define JITTER_SLOW_REGISTER_OFFSET0 ((((union jitter_word*)jitter_ip)[0]).fixnum)
#else
# define JITTER_SLOW_REGISTER_OFFSET0 ((((union jitter_word*)jitter_ip)[1]).fixnum)
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
  /* Define a macro expanding to an l-value for the VM register content. */
#   define JITTER_ARG0  JITTER_SLOW_REGISTER_FROM_OFFSET(r, JITTER_SLOW_REGISTER_OFFSET0)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a slow (therefore residual, passed as an offset)
        register. */
  /* Define a macro expanding to the slow register offset. */
#if defined(JITTER_DISPATCH_NO_THREADING)
# define JITTER_SLOW_REGISTER_OFFSET1 (JITTER_RESIDUAL_ARGUMENT_1.fixnum)
#elif defined (JITTER_DISPATCH_MINIMAL_THREADING)
# define JITTER_SLOW_REGISTER_OFFSET1 ((((union jitter_word*)jitter_ip)[1]).fixnum)
#else
# define JITTER_SLOW_REGISTER_OFFSET1 ((((union jitter_word*)jitter_ip)[2]).fixnum)
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
  /* Define a macro expanding to an l-value for the VM register content. */
#   define JITTER_ARG1  JITTER_SLOW_REGISTER_FROM_OFFSET(r, JITTER_SLOW_REGISTER_OFFSET1)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

    /* The 2th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG2  JITTER_RESIDUAL_ARGUMENT_2
    JITTER_MARK_RESIDUAL_2_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[2])
#else
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[3])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN2 (JITTER_ARG2.fixnum)
#   define JITTER_ARGU2 (JITTER_ARG2.ufixnum)
#   define JITTER_ARGP2 (JITTER_ARG2.pointer)
#   define JITTER_ARGF2 JITTER_ARGP2

    /* The 3th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG3  JITTER_RESIDUAL_ARGUMENT_3
    JITTER_MARK_RESIDUAL_3_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG3  (((union jitter_word*)jitter_ip)[3])
#else
#   define JITTER_ARG3  (((union jitter_word*)jitter_ip)[4])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN3 (JITTER_ARG3.fixnum)
#   define JITTER_ARGU3 (JITTER_ARG3.ufixnum)
#   define JITTER_ARGP3 (JITTER_ARG3.pointer)
#   define JITTER_ARGF3 JITTER_ARGP3

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* When jumping to the non-relocatable part it is important not
   to use a fallback version of JITTER_COMPUTED_GOTO, in order to
   prevent GCC from tail-merging. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
    /* Jump to non-relocatable code. */
    JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);

    /* Here the residual arity is given as zero: it's too late to
       skip residuals, since we've already jumped and this code is
       unreachable.  The instruction pointer, if any, is advanced
       in the non-relocatable code. */
    JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-cdr-register/%rR/%rR/fR/retR, _eREPLACEMENT_mcdr_mregister___rrR___rrR__fR__retR, 0)

    /* Relocated code will jump to this label in non-relocated code. */
  JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
    JITTER_COMMENT_IN_ASM_("!REPLACEMENT-cdr-register/%rR/%rR/fR/retR non-relocatable code");
#endif // #ifdef JITTER_REPLICATE
#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of !REPLACEMENT-cdr-register/%rR/%rR/fR/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  no. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
//#if 0
  //fprintf (stderr, "Executing instruction %s..\n", "!REPLACEMENT-cdr-register/%rR/%rR/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing replacement instruction %s..\n", "!REPLACEMENT-cdr-register/%rR/%rR/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing non-relocatable instruction %s with JITTER_SPECIALIZED_INSTRUCTION_WORD_NO=%i..\n", "!REPLACEMENT-cdr-register/%rR/%rR/fR/retR", (int) JITTER_SPECIALIZED_INSTRUCTION_WORD_NO); fflush (stderr);
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#undef JITTER_THIS_IS_A_REPLACEMENT
#define JITTER_THIS_IS_A_REPLACEMENT 1

    /* User code for !REPLACEMENT-cdr-register/%rR/%rR/fR/retR . */
  {
/* User-specified code, user code block part: beginning. */

#if ! defined (JITTERLISP_UNSAFE)
    JITTERLISP_BRANCH_FAST_UNLESS_CONS (JITTER_ARG0, JITTER_ARGF2);
#endif
    JITTERLISP_CDR_(JITTER_ARG1,
                    JITTER_ARG0);
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for !REPLACEMENT-cdr-register/%rR/%rR/fR/retR . */

  //fprintf (stderr, "..Executed replacement instruction %s\n", "!REPLACEMENT-cdr-register/%rR/%rR/fR/retR");
  //fprintf (stderr, "..Executed instruction %s\n", "!REPLACEMENT-cdr-register/%rR/%rR/fR/retR");
//#endif // #if 0
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
#ifdef JITTER_REPLICATE
  {
    /* Advance the instruction pointer, if any, to skip every
       residual but the last; branch back to replicated
       code. */
    const void *_jitter_back_to_replicated_code_pointer =
      JITTER_ARGP3;
    JITTER_SKIP_RESIDUALS_;
    goto * _jitter_back_to_replicated_code_pointer;
  }
#endif // #ifdef JITTER_REPLICATE

    /* Undefine the !REPLACEMENT-cdr-register/%rR/%rR/fR/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1
#   undef JITTER_SLOW_REGISTER_OFFSET2
#   undef JITTER_ARG2
#   undef JITTER_ARGN2
#   undef JITTER_ARGU2
#   undef JITTER_ARGP2
#   undef JITTER_ARGF2
#   undef JITTER_SLOW_REGISTER_OFFSET3
#   undef JITTER_ARG3
#   undef JITTER_ARGN3
#   undef JITTER_ARGU3
#   undef JITTER_ARGP3
#   undef JITTER_ARGF3

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#ifndef JITTER_REPLICATE
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-cdr-register/%rR/%rR/fR/retR, _eREPLACEMENT_mcdr_mregister___rrR___rrR__fR__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#endif // #ifndef JITTER_REPLICATE
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for !REPLACEMENT-cdr-register/%rR/%rR/fR/retR, which started with its
       definitions. */
  }
#endif // #if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
/*  End of !REPLACEMENT-cdr-register/%rR/%rR/fR/retR , a replacement specialised instruction */

  /* Ordinary specialised instruction !REPLACEMENT-check-closure/fR/retR (replacement) */
  /* Omit this specialised instruction altogether unless
     replacements are in fact supported in this
     configuration. */
#if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
  JITTER_INSTRUCTION_PROLOG_(!REPLACEMENT-check-closure/fR/retR, _eREPLACEMENT_mcheck_mclosure__fR__retR, cold)
  { /* This block begins with definitions for !REPLACEMENT-check-closure/fR/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       260
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         !REPLACEMENT-check-closure/fR/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "check-closure"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "!REPLACEMENT-check-closure/fR/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _eREPLACEMENT_mcheck_mclosure__fR__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST JITTER_BRANCH
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 2

  /* Define argument-access macros for !REPLACEMENT-check-closure/fR/retR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
    /* The 0th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* When jumping to the non-relocatable part it is important not
   to use a fallback version of JITTER_COMPUTED_GOTO, in order to
   prevent GCC from tail-merging. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
    /* Jump to non-relocatable code. */
    JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);

    /* Here the residual arity is given as zero: it's too late to
       skip residuals, since we've already jumped and this code is
       unreachable.  The instruction pointer, if any, is advanced
       in the non-relocatable code. */
    JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-check-closure/fR/retR, _eREPLACEMENT_mcheck_mclosure__fR__retR, 0)

    /* Relocated code will jump to this label in non-relocated code. */
  JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
    JITTER_COMMENT_IN_ASM_("!REPLACEMENT-check-closure/fR/retR non-relocatable code");
#endif // #ifdef JITTER_REPLICATE
#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of !REPLACEMENT-check-closure/fR/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  no. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
//#if 0
  //fprintf (stderr, "Executing instruction %s..\n", "!REPLACEMENT-check-closure/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing replacement instruction %s..\n", "!REPLACEMENT-check-closure/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing non-relocatable instruction %s with JITTER_SPECIALIZED_INSTRUCTION_WORD_NO=%i..\n", "!REPLACEMENT-check-closure/fR/retR", (int) JITTER_SPECIALIZED_INSTRUCTION_WORD_NO); fflush (stderr);
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#undef JITTER_THIS_IS_A_REPLACEMENT
#define JITTER_THIS_IS_A_REPLACEMENT 1

    /* User code for !REPLACEMENT-check-closure/fR/retR . */
  {
/* User-specified code, user code block part: beginning. */

#   ifndef JITTERLISP_UNSAFE
      jitterlisp_object top = JITTER_TOP_MAINSTACK();
      if (! JITTERLISP_IS_CLOSURE(top))
        JITTER_BRANCH_FAST(JITTER_ARGF0);
#   endif // #ifndef JITTERLISP_UNSAFE
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for !REPLACEMENT-check-closure/fR/retR . */

  //fprintf (stderr, "..Executed replacement instruction %s\n", "!REPLACEMENT-check-closure/fR/retR");
  //fprintf (stderr, "..Executed instruction %s\n", "!REPLACEMENT-check-closure/fR/retR");
//#endif // #if 0
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
#ifdef JITTER_REPLICATE
  {
    /* Advance the instruction pointer, if any, to skip every
       residual but the last; branch back to replicated
       code. */
    const void *_jitter_back_to_replicated_code_pointer =
      JITTER_ARGP1;
    JITTER_SKIP_RESIDUALS_;
    goto * _jitter_back_to_replicated_code_pointer;
  }
#endif // #ifdef JITTER_REPLICATE

    /* Undefine the !REPLACEMENT-check-closure/fR/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#ifndef JITTER_REPLICATE
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-check-closure/fR/retR, _eREPLACEMENT_mcheck_mclosure__fR__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#endif // #ifndef JITTER_REPLICATE
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for !REPLACEMENT-check-closure/fR/retR, which started with its
       definitions. */
  }
#endif // #if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
/*  End of !REPLACEMENT-check-closure/fR/retR , a replacement specialised instruction */

  /* Ordinary specialised instruction !REPLACEMENT-check-global-defined/nR/fR/retR (replacement) */
  /* Omit this specialised instruction altogether unless
     replacements are in fact supported in this
     configuration. */
#if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
  JITTER_INSTRUCTION_PROLOG_(!REPLACEMENT-check-global-defined/nR/fR/retR, _eREPLACEMENT_mcheck_mglobal_mdefined__nR__fR__retR, cold)
  { /* This block begins with definitions for !REPLACEMENT-check-global-defined/nR/fR/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       261
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         !REPLACEMENT-check-global-defined/nR/fR/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "check-global-defined"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "!REPLACEMENT-check-global-defined/nR/fR/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _eREPLACEMENT_mcheck_mglobal_mdefined__nR__fR__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is non-relocatable.
       Its 2-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST JITTER_BRANCH
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
    /* This specialized instruction is non-relocatable.
       Its 2-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 3

  /* Define argument-access macros for !REPLACEMENT-check-global-defined/nR/fR/retR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a residual literal. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

    /* The 2th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG2  JITTER_RESIDUAL_ARGUMENT_2
    JITTER_MARK_RESIDUAL_2_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[2])
#else
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[3])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN2 (JITTER_ARG2.fixnum)
#   define JITTER_ARGU2 (JITTER_ARG2.ufixnum)
#   define JITTER_ARGP2 (JITTER_ARG2.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
    /* The 0th argument is a residual literal. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

    /* The 2th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG2  JITTER_RESIDUAL_ARGUMENT_2
    JITTER_MARK_RESIDUAL_2_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[2])
#else
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[3])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN2 (JITTER_ARG2.fixnum)
#   define JITTER_ARGU2 (JITTER_ARG2.ufixnum)
#   define JITTER_ARGP2 (JITTER_ARG2.pointer)
#   define JITTER_ARGF2 JITTER_ARGP2

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* When jumping to the non-relocatable part it is important not
   to use a fallback version of JITTER_COMPUTED_GOTO, in order to
   prevent GCC from tail-merging. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
    /* Jump to non-relocatable code. */
    JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);

    /* Here the residual arity is given as zero: it's too late to
       skip residuals, since we've already jumped and this code is
       unreachable.  The instruction pointer, if any, is advanced
       in the non-relocatable code. */
    JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-check-global-defined/nR/fR/retR, _eREPLACEMENT_mcheck_mglobal_mdefined__nR__fR__retR, 0)

    /* Relocated code will jump to this label in non-relocated code. */
  JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
    JITTER_COMMENT_IN_ASM_("!REPLACEMENT-check-global-defined/nR/fR/retR non-relocatable code");
#endif // #ifdef JITTER_REPLICATE
#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of !REPLACEMENT-check-global-defined/nR/fR/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  no. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
//#if 0
  //fprintf (stderr, "Executing instruction %s..\n", "!REPLACEMENT-check-global-defined/nR/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing replacement instruction %s..\n", "!REPLACEMENT-check-global-defined/nR/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing non-relocatable instruction %s with JITTER_SPECIALIZED_INSTRUCTION_WORD_NO=%i..\n", "!REPLACEMENT-check-global-defined/nR/fR/retR", (int) JITTER_SPECIALIZED_INSTRUCTION_WORD_NO); fflush (stderr);
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#undef JITTER_THIS_IS_A_REPLACEMENT
#define JITTER_THIS_IS_A_REPLACEMENT 1

    /* User code for !REPLACEMENT-check-global-defined/nR/fR/retR . */
  {
/* User-specified code, user code block part: beginning. */

#ifndef JITTERLISP_UNSAFE
    jitterlisp_object tagged_symbol = JITTER_ARGN0;
    struct jitterlisp_symbol * symbol = JITTERLISP_SYMBOL_DECODE(tagged_symbol);
    JITTER_BRANCH_FAST_IF_EQUAL (symbol->global_value, JITTERLISP_UNDEFINED,
                                 JITTER_ARGF1);
#endif // #ifndef JITTERLISP_UNSAFE
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for !REPLACEMENT-check-global-defined/nR/fR/retR . */

  //fprintf (stderr, "..Executed replacement instruction %s\n", "!REPLACEMENT-check-global-defined/nR/fR/retR");
  //fprintf (stderr, "..Executed instruction %s\n", "!REPLACEMENT-check-global-defined/nR/fR/retR");
//#endif // #if 0
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
#ifdef JITTER_REPLICATE
  {
    /* Advance the instruction pointer, if any, to skip every
       residual but the last; branch back to replicated
       code. */
    const void *_jitter_back_to_replicated_code_pointer =
      JITTER_ARGP2;
    JITTER_SKIP_RESIDUALS_;
    goto * _jitter_back_to_replicated_code_pointer;
  }
#endif // #ifdef JITTER_REPLICATE

    /* Undefine the !REPLACEMENT-check-global-defined/nR/fR/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1
#   undef JITTER_SLOW_REGISTER_OFFSET2
#   undef JITTER_ARG2
#   undef JITTER_ARGN2
#   undef JITTER_ARGU2
#   undef JITTER_ARGP2
#   undef JITTER_ARGF2

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#ifndef JITTER_REPLICATE
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-check-global-defined/nR/fR/retR, _eREPLACEMENT_mcheck_mglobal_mdefined__nR__fR__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#endif // #ifndef JITTER_REPLICATE
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for !REPLACEMENT-check-global-defined/nR/fR/retR, which started with its
       definitions. */
  }
#endif // #if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
/*  End of !REPLACEMENT-check-global-defined/nR/fR/retR , a replacement specialised instruction */

  /* Ordinary specialised instruction !REPLACEMENT-check-in-arity/n0/fR/retR (replacement) */
  /* Omit this specialised instruction altogether unless
     replacements are in fact supported in this
     configuration. */
#if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
  JITTER_INSTRUCTION_PROLOG_(!REPLACEMENT-check-in-arity/n0/fR/retR, _eREPLACEMENT_mcheck_min_marity__n0__fR__retR, cold)
  { /* This block begins with definitions for !REPLACEMENT-check-in-arity/n0/fR/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       262
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         !REPLACEMENT-check-in-arity/n0/fR/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "check-in-arity"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "!REPLACEMENT-check-in-arity/n0/fR/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _eREPLACEMENT_mcheck_min_marity__n0__fR__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is non-relocatable.
       Its 2-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST JITTER_BRANCH
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
    /* This specialized instruction is non-relocatable.
       Its 2-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 2

  /* Define argument-access macros for !REPLACEMENT-check-in-arity/n0/fR/retR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 0L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

    /* The 2th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG2  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN2 (JITTER_ARG2.fixnum)
#   define JITTER_ARGU2 (JITTER_ARG2.ufixnum)
#   define JITTER_ARGP2 (JITTER_ARG2.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 0L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

    /* The 2th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG2  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN2 (JITTER_ARG2.fixnum)
#   define JITTER_ARGU2 (JITTER_ARG2.ufixnum)
#   define JITTER_ARGP2 (JITTER_ARG2.pointer)
#   define JITTER_ARGF2 JITTER_ARGP2

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* When jumping to the non-relocatable part it is important not
   to use a fallback version of JITTER_COMPUTED_GOTO, in order to
   prevent GCC from tail-merging. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
    /* Jump to non-relocatable code. */
    JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);

    /* Here the residual arity is given as zero: it's too late to
       skip residuals, since we've already jumped and this code is
       unreachable.  The instruction pointer, if any, is advanced
       in the non-relocatable code. */
    JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-check-in-arity/n0/fR/retR, _eREPLACEMENT_mcheck_min_marity__n0__fR__retR, 0)

    /* Relocated code will jump to this label in non-relocated code. */
  JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
    JITTER_COMMENT_IN_ASM_("!REPLACEMENT-check-in-arity/n0/fR/retR non-relocatable code");
#endif // #ifdef JITTER_REPLICATE
#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of !REPLACEMENT-check-in-arity/n0/fR/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  no. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
//#if 0
  //fprintf (stderr, "Executing instruction %s..\n", "!REPLACEMENT-check-in-arity/n0/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing replacement instruction %s..\n", "!REPLACEMENT-check-in-arity/n0/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing non-relocatable instruction %s with JITTER_SPECIALIZED_INSTRUCTION_WORD_NO=%i..\n", "!REPLACEMENT-check-in-arity/n0/fR/retR", (int) JITTER_SPECIALIZED_INSTRUCTION_WORD_NO); fflush (stderr);
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#undef JITTER_THIS_IS_A_REPLACEMENT
#define JITTER_THIS_IS_A_REPLACEMENT 1

    /* User code for !REPLACEMENT-check-in-arity/n0/fR/retR . */
  {
/* User-specified code, user code block part: beginning. */

#   ifndef JITTERLISP_UNSAFE
      /* Here we can assume that the top object is a closure, without checking:
         we either already performed a type check, or the compiler decided it
         wasn't necessary. */
      jitterlisp_object top = JITTER_TOP_MAINSTACK();
      struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(top);

      JITTER_BRANCH_FAST_IF_NOTEQUAL(c->in_arity, JITTER_ARGN0, JITTER_ARGF1);
#   endif // #ifndef JITTERLISP_UNSAFE
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for !REPLACEMENT-check-in-arity/n0/fR/retR . */

  //fprintf (stderr, "..Executed replacement instruction %s\n", "!REPLACEMENT-check-in-arity/n0/fR/retR");
  //fprintf (stderr, "..Executed instruction %s\n", "!REPLACEMENT-check-in-arity/n0/fR/retR");
//#endif // #if 0
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
#ifdef JITTER_REPLICATE
  {
    /* Advance the instruction pointer, if any, to skip every
       residual but the last; branch back to replicated
       code. */
    const void *_jitter_back_to_replicated_code_pointer =
      JITTER_ARGP2;
    JITTER_SKIP_RESIDUALS_;
    goto * _jitter_back_to_replicated_code_pointer;
  }
#endif // #ifdef JITTER_REPLICATE

    /* Undefine the !REPLACEMENT-check-in-arity/n0/fR/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1
#   undef JITTER_SLOW_REGISTER_OFFSET2
#   undef JITTER_ARG2
#   undef JITTER_ARGN2
#   undef JITTER_ARGU2
#   undef JITTER_ARGP2
#   undef JITTER_ARGF2

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#ifndef JITTER_REPLICATE
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-check-in-arity/n0/fR/retR, _eREPLACEMENT_mcheck_min_marity__n0__fR__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#endif // #ifndef JITTER_REPLICATE
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for !REPLACEMENT-check-in-arity/n0/fR/retR, which started with its
       definitions. */
  }
#endif // #if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
/*  End of !REPLACEMENT-check-in-arity/n0/fR/retR , a replacement specialised instruction */

  /* Ordinary specialised instruction !REPLACEMENT-check-in-arity/n1/fR/retR (replacement) */
  /* Omit this specialised instruction altogether unless
     replacements are in fact supported in this
     configuration. */
#if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
  JITTER_INSTRUCTION_PROLOG_(!REPLACEMENT-check-in-arity/n1/fR/retR, _eREPLACEMENT_mcheck_min_marity__n1__fR__retR, cold)
  { /* This block begins with definitions for !REPLACEMENT-check-in-arity/n1/fR/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       263
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         !REPLACEMENT-check-in-arity/n1/fR/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "check-in-arity"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "!REPLACEMENT-check-in-arity/n1/fR/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _eREPLACEMENT_mcheck_min_marity__n1__fR__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is non-relocatable.
       Its 2-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST JITTER_BRANCH
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
    /* This specialized instruction is non-relocatable.
       Its 2-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 2

  /* Define argument-access macros for !REPLACEMENT-check-in-arity/n1/fR/retR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 1L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

    /* The 2th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG2  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN2 (JITTER_ARG2.fixnum)
#   define JITTER_ARGU2 (JITTER_ARG2.ufixnum)
#   define JITTER_ARGP2 (JITTER_ARG2.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 1L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

    /* The 2th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG2  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN2 (JITTER_ARG2.fixnum)
#   define JITTER_ARGU2 (JITTER_ARG2.ufixnum)
#   define JITTER_ARGP2 (JITTER_ARG2.pointer)
#   define JITTER_ARGF2 JITTER_ARGP2

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* When jumping to the non-relocatable part it is important not
   to use a fallback version of JITTER_COMPUTED_GOTO, in order to
   prevent GCC from tail-merging. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
    /* Jump to non-relocatable code. */
    JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);

    /* Here the residual arity is given as zero: it's too late to
       skip residuals, since we've already jumped and this code is
       unreachable.  The instruction pointer, if any, is advanced
       in the non-relocatable code. */
    JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-check-in-arity/n1/fR/retR, _eREPLACEMENT_mcheck_min_marity__n1__fR__retR, 0)

    /* Relocated code will jump to this label in non-relocated code. */
  JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
    JITTER_COMMENT_IN_ASM_("!REPLACEMENT-check-in-arity/n1/fR/retR non-relocatable code");
#endif // #ifdef JITTER_REPLICATE
#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of !REPLACEMENT-check-in-arity/n1/fR/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  no. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
//#if 0
  //fprintf (stderr, "Executing instruction %s..\n", "!REPLACEMENT-check-in-arity/n1/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing replacement instruction %s..\n", "!REPLACEMENT-check-in-arity/n1/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing non-relocatable instruction %s with JITTER_SPECIALIZED_INSTRUCTION_WORD_NO=%i..\n", "!REPLACEMENT-check-in-arity/n1/fR/retR", (int) JITTER_SPECIALIZED_INSTRUCTION_WORD_NO); fflush (stderr);
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#undef JITTER_THIS_IS_A_REPLACEMENT
#define JITTER_THIS_IS_A_REPLACEMENT 1

    /* User code for !REPLACEMENT-check-in-arity/n1/fR/retR . */
  {
/* User-specified code, user code block part: beginning. */

#   ifndef JITTERLISP_UNSAFE
      /* Here we can assume that the top object is a closure, without checking:
         we either already performed a type check, or the compiler decided it
         wasn't necessary. */
      jitterlisp_object top = JITTER_TOP_MAINSTACK();
      struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(top);

      JITTER_BRANCH_FAST_IF_NOTEQUAL(c->in_arity, JITTER_ARGN0, JITTER_ARGF1);
#   endif // #ifndef JITTERLISP_UNSAFE
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for !REPLACEMENT-check-in-arity/n1/fR/retR . */

  //fprintf (stderr, "..Executed replacement instruction %s\n", "!REPLACEMENT-check-in-arity/n1/fR/retR");
  //fprintf (stderr, "..Executed instruction %s\n", "!REPLACEMENT-check-in-arity/n1/fR/retR");
//#endif // #if 0
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
#ifdef JITTER_REPLICATE
  {
    /* Advance the instruction pointer, if any, to skip every
       residual but the last; branch back to replicated
       code. */
    const void *_jitter_back_to_replicated_code_pointer =
      JITTER_ARGP2;
    JITTER_SKIP_RESIDUALS_;
    goto * _jitter_back_to_replicated_code_pointer;
  }
#endif // #ifdef JITTER_REPLICATE

    /* Undefine the !REPLACEMENT-check-in-arity/n1/fR/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1
#   undef JITTER_SLOW_REGISTER_OFFSET2
#   undef JITTER_ARG2
#   undef JITTER_ARGN2
#   undef JITTER_ARGU2
#   undef JITTER_ARGP2
#   undef JITTER_ARGF2

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#ifndef JITTER_REPLICATE
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-check-in-arity/n1/fR/retR, _eREPLACEMENT_mcheck_min_marity__n1__fR__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#endif // #ifndef JITTER_REPLICATE
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for !REPLACEMENT-check-in-arity/n1/fR/retR, which started with its
       definitions. */
  }
#endif // #if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
/*  End of !REPLACEMENT-check-in-arity/n1/fR/retR , a replacement specialised instruction */

  /* Ordinary specialised instruction !REPLACEMENT-check-in-arity/n2/fR/retR (replacement) */
  /* Omit this specialised instruction altogether unless
     replacements are in fact supported in this
     configuration. */
#if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
  JITTER_INSTRUCTION_PROLOG_(!REPLACEMENT-check-in-arity/n2/fR/retR, _eREPLACEMENT_mcheck_min_marity__n2__fR__retR, cold)
  { /* This block begins with definitions for !REPLACEMENT-check-in-arity/n2/fR/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       264
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         !REPLACEMENT-check-in-arity/n2/fR/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "check-in-arity"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "!REPLACEMENT-check-in-arity/n2/fR/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _eREPLACEMENT_mcheck_min_marity__n2__fR__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is non-relocatable.
       Its 2-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST JITTER_BRANCH
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
    /* This specialized instruction is non-relocatable.
       Its 2-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 2

  /* Define argument-access macros for !REPLACEMENT-check-in-arity/n2/fR/retR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 2L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

    /* The 2th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG2  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN2 (JITTER_ARG2.fixnum)
#   define JITTER_ARGU2 (JITTER_ARG2.ufixnum)
#   define JITTER_ARGP2 (JITTER_ARG2.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 2L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

    /* The 2th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG2  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN2 (JITTER_ARG2.fixnum)
#   define JITTER_ARGU2 (JITTER_ARG2.ufixnum)
#   define JITTER_ARGP2 (JITTER_ARG2.pointer)
#   define JITTER_ARGF2 JITTER_ARGP2

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* When jumping to the non-relocatable part it is important not
   to use a fallback version of JITTER_COMPUTED_GOTO, in order to
   prevent GCC from tail-merging. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
    /* Jump to non-relocatable code. */
    JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);

    /* Here the residual arity is given as zero: it's too late to
       skip residuals, since we've already jumped and this code is
       unreachable.  The instruction pointer, if any, is advanced
       in the non-relocatable code. */
    JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-check-in-arity/n2/fR/retR, _eREPLACEMENT_mcheck_min_marity__n2__fR__retR, 0)

    /* Relocated code will jump to this label in non-relocated code. */
  JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
    JITTER_COMMENT_IN_ASM_("!REPLACEMENT-check-in-arity/n2/fR/retR non-relocatable code");
#endif // #ifdef JITTER_REPLICATE
#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of !REPLACEMENT-check-in-arity/n2/fR/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  no. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
//#if 0
  //fprintf (stderr, "Executing instruction %s..\n", "!REPLACEMENT-check-in-arity/n2/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing replacement instruction %s..\n", "!REPLACEMENT-check-in-arity/n2/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing non-relocatable instruction %s with JITTER_SPECIALIZED_INSTRUCTION_WORD_NO=%i..\n", "!REPLACEMENT-check-in-arity/n2/fR/retR", (int) JITTER_SPECIALIZED_INSTRUCTION_WORD_NO); fflush (stderr);
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#undef JITTER_THIS_IS_A_REPLACEMENT
#define JITTER_THIS_IS_A_REPLACEMENT 1

    /* User code for !REPLACEMENT-check-in-arity/n2/fR/retR . */
  {
/* User-specified code, user code block part: beginning. */

#   ifndef JITTERLISP_UNSAFE
      /* Here we can assume that the top object is a closure, without checking:
         we either already performed a type check, or the compiler decided it
         wasn't necessary. */
      jitterlisp_object top = JITTER_TOP_MAINSTACK();
      struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(top);

      JITTER_BRANCH_FAST_IF_NOTEQUAL(c->in_arity, JITTER_ARGN0, JITTER_ARGF1);
#   endif // #ifndef JITTERLISP_UNSAFE
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for !REPLACEMENT-check-in-arity/n2/fR/retR . */

  //fprintf (stderr, "..Executed replacement instruction %s\n", "!REPLACEMENT-check-in-arity/n2/fR/retR");
  //fprintf (stderr, "..Executed instruction %s\n", "!REPLACEMENT-check-in-arity/n2/fR/retR");
//#endif // #if 0
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
#ifdef JITTER_REPLICATE
  {
    /* Advance the instruction pointer, if any, to skip every
       residual but the last; branch back to replicated
       code. */
    const void *_jitter_back_to_replicated_code_pointer =
      JITTER_ARGP2;
    JITTER_SKIP_RESIDUALS_;
    goto * _jitter_back_to_replicated_code_pointer;
  }
#endif // #ifdef JITTER_REPLICATE

    /* Undefine the !REPLACEMENT-check-in-arity/n2/fR/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1
#   undef JITTER_SLOW_REGISTER_OFFSET2
#   undef JITTER_ARG2
#   undef JITTER_ARGN2
#   undef JITTER_ARGU2
#   undef JITTER_ARGP2
#   undef JITTER_ARGF2

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#ifndef JITTER_REPLICATE
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-check-in-arity/n2/fR/retR, _eREPLACEMENT_mcheck_min_marity__n2__fR__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#endif // #ifndef JITTER_REPLICATE
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for !REPLACEMENT-check-in-arity/n2/fR/retR, which started with its
       definitions. */
  }
#endif // #if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
/*  End of !REPLACEMENT-check-in-arity/n2/fR/retR , a replacement specialised instruction */

  /* Ordinary specialised instruction !REPLACEMENT-check-in-arity/n3/fR/retR (replacement) */
  /* Omit this specialised instruction altogether unless
     replacements are in fact supported in this
     configuration. */
#if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
  JITTER_INSTRUCTION_PROLOG_(!REPLACEMENT-check-in-arity/n3/fR/retR, _eREPLACEMENT_mcheck_min_marity__n3__fR__retR, cold)
  { /* This block begins with definitions for !REPLACEMENT-check-in-arity/n3/fR/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       265
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         !REPLACEMENT-check-in-arity/n3/fR/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "check-in-arity"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "!REPLACEMENT-check-in-arity/n3/fR/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _eREPLACEMENT_mcheck_min_marity__n3__fR__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is non-relocatable.
       Its 2-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST JITTER_BRANCH
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
    /* This specialized instruction is non-relocatable.
       Its 2-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 2

  /* Define argument-access macros for !REPLACEMENT-check-in-arity/n3/fR/retR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 3L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

    /* The 2th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG2  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN2 (JITTER_ARG2.fixnum)
#   define JITTER_ARGU2 (JITTER_ARG2.ufixnum)
#   define JITTER_ARGP2 (JITTER_ARG2.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 3L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

    /* The 2th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG2  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN2 (JITTER_ARG2.fixnum)
#   define JITTER_ARGU2 (JITTER_ARG2.ufixnum)
#   define JITTER_ARGP2 (JITTER_ARG2.pointer)
#   define JITTER_ARGF2 JITTER_ARGP2

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* When jumping to the non-relocatable part it is important not
   to use a fallback version of JITTER_COMPUTED_GOTO, in order to
   prevent GCC from tail-merging. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
    /* Jump to non-relocatable code. */
    JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);

    /* Here the residual arity is given as zero: it's too late to
       skip residuals, since we've already jumped and this code is
       unreachable.  The instruction pointer, if any, is advanced
       in the non-relocatable code. */
    JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-check-in-arity/n3/fR/retR, _eREPLACEMENT_mcheck_min_marity__n3__fR__retR, 0)

    /* Relocated code will jump to this label in non-relocated code. */
  JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
    JITTER_COMMENT_IN_ASM_("!REPLACEMENT-check-in-arity/n3/fR/retR non-relocatable code");
#endif // #ifdef JITTER_REPLICATE
#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of !REPLACEMENT-check-in-arity/n3/fR/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  no. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
//#if 0
  //fprintf (stderr, "Executing instruction %s..\n", "!REPLACEMENT-check-in-arity/n3/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing replacement instruction %s..\n", "!REPLACEMENT-check-in-arity/n3/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing non-relocatable instruction %s with JITTER_SPECIALIZED_INSTRUCTION_WORD_NO=%i..\n", "!REPLACEMENT-check-in-arity/n3/fR/retR", (int) JITTER_SPECIALIZED_INSTRUCTION_WORD_NO); fflush (stderr);
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#undef JITTER_THIS_IS_A_REPLACEMENT
#define JITTER_THIS_IS_A_REPLACEMENT 1

    /* User code for !REPLACEMENT-check-in-arity/n3/fR/retR . */
  {
/* User-specified code, user code block part: beginning. */

#   ifndef JITTERLISP_UNSAFE
      /* Here we can assume that the top object is a closure, without checking:
         we either already performed a type check, or the compiler decided it
         wasn't necessary. */
      jitterlisp_object top = JITTER_TOP_MAINSTACK();
      struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(top);

      JITTER_BRANCH_FAST_IF_NOTEQUAL(c->in_arity, JITTER_ARGN0, JITTER_ARGF1);
#   endif // #ifndef JITTERLISP_UNSAFE
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for !REPLACEMENT-check-in-arity/n3/fR/retR . */

  //fprintf (stderr, "..Executed replacement instruction %s\n", "!REPLACEMENT-check-in-arity/n3/fR/retR");
  //fprintf (stderr, "..Executed instruction %s\n", "!REPLACEMENT-check-in-arity/n3/fR/retR");
//#endif // #if 0
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
#ifdef JITTER_REPLICATE
  {
    /* Advance the instruction pointer, if any, to skip every
       residual but the last; branch back to replicated
       code. */
    const void *_jitter_back_to_replicated_code_pointer =
      JITTER_ARGP2;
    JITTER_SKIP_RESIDUALS_;
    goto * _jitter_back_to_replicated_code_pointer;
  }
#endif // #ifdef JITTER_REPLICATE

    /* Undefine the !REPLACEMENT-check-in-arity/n3/fR/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1
#   undef JITTER_SLOW_REGISTER_OFFSET2
#   undef JITTER_ARG2
#   undef JITTER_ARGN2
#   undef JITTER_ARGU2
#   undef JITTER_ARGP2
#   undef JITTER_ARGF2

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#ifndef JITTER_REPLICATE
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-check-in-arity/n3/fR/retR, _eREPLACEMENT_mcheck_min_marity__n3__fR__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#endif // #ifndef JITTER_REPLICATE
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for !REPLACEMENT-check-in-arity/n3/fR/retR, which started with its
       definitions. */
  }
#endif // #if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
/*  End of !REPLACEMENT-check-in-arity/n3/fR/retR , a replacement specialised instruction */

  /* Ordinary specialised instruction !REPLACEMENT-check-in-arity/n4/fR/retR (replacement) */
  /* Omit this specialised instruction altogether unless
     replacements are in fact supported in this
     configuration. */
#if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
  JITTER_INSTRUCTION_PROLOG_(!REPLACEMENT-check-in-arity/n4/fR/retR, _eREPLACEMENT_mcheck_min_marity__n4__fR__retR, cold)
  { /* This block begins with definitions for !REPLACEMENT-check-in-arity/n4/fR/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       266
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         !REPLACEMENT-check-in-arity/n4/fR/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "check-in-arity"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "!REPLACEMENT-check-in-arity/n4/fR/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _eREPLACEMENT_mcheck_min_marity__n4__fR__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is non-relocatable.
       Its 2-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST JITTER_BRANCH
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
    /* This specialized instruction is non-relocatable.
       Its 2-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 2

  /* Define argument-access macros for !REPLACEMENT-check-in-arity/n4/fR/retR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 4L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

    /* The 2th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG2  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN2 (JITTER_ARG2.fixnum)
#   define JITTER_ARGU2 (JITTER_ARG2.ufixnum)
#   define JITTER_ARGP2 (JITTER_ARG2.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 4L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

    /* The 2th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG2  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN2 (JITTER_ARG2.fixnum)
#   define JITTER_ARGU2 (JITTER_ARG2.ufixnum)
#   define JITTER_ARGP2 (JITTER_ARG2.pointer)
#   define JITTER_ARGF2 JITTER_ARGP2

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* When jumping to the non-relocatable part it is important not
   to use a fallback version of JITTER_COMPUTED_GOTO, in order to
   prevent GCC from tail-merging. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
    /* Jump to non-relocatable code. */
    JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);

    /* Here the residual arity is given as zero: it's too late to
       skip residuals, since we've already jumped and this code is
       unreachable.  The instruction pointer, if any, is advanced
       in the non-relocatable code. */
    JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-check-in-arity/n4/fR/retR, _eREPLACEMENT_mcheck_min_marity__n4__fR__retR, 0)

    /* Relocated code will jump to this label in non-relocated code. */
  JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
    JITTER_COMMENT_IN_ASM_("!REPLACEMENT-check-in-arity/n4/fR/retR non-relocatable code");
#endif // #ifdef JITTER_REPLICATE
#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of !REPLACEMENT-check-in-arity/n4/fR/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  no. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
//#if 0
  //fprintf (stderr, "Executing instruction %s..\n", "!REPLACEMENT-check-in-arity/n4/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing replacement instruction %s..\n", "!REPLACEMENT-check-in-arity/n4/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing non-relocatable instruction %s with JITTER_SPECIALIZED_INSTRUCTION_WORD_NO=%i..\n", "!REPLACEMENT-check-in-arity/n4/fR/retR", (int) JITTER_SPECIALIZED_INSTRUCTION_WORD_NO); fflush (stderr);
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#undef JITTER_THIS_IS_A_REPLACEMENT
#define JITTER_THIS_IS_A_REPLACEMENT 1

    /* User code for !REPLACEMENT-check-in-arity/n4/fR/retR . */
  {
/* User-specified code, user code block part: beginning. */

#   ifndef JITTERLISP_UNSAFE
      /* Here we can assume that the top object is a closure, without checking:
         we either already performed a type check, or the compiler decided it
         wasn't necessary. */
      jitterlisp_object top = JITTER_TOP_MAINSTACK();
      struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(top);

      JITTER_BRANCH_FAST_IF_NOTEQUAL(c->in_arity, JITTER_ARGN0, JITTER_ARGF1);
#   endif // #ifndef JITTERLISP_UNSAFE
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for !REPLACEMENT-check-in-arity/n4/fR/retR . */

  //fprintf (stderr, "..Executed replacement instruction %s\n", "!REPLACEMENT-check-in-arity/n4/fR/retR");
  //fprintf (stderr, "..Executed instruction %s\n", "!REPLACEMENT-check-in-arity/n4/fR/retR");
//#endif // #if 0
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
#ifdef JITTER_REPLICATE
  {
    /* Advance the instruction pointer, if any, to skip every
       residual but the last; branch back to replicated
       code. */
    const void *_jitter_back_to_replicated_code_pointer =
      JITTER_ARGP2;
    JITTER_SKIP_RESIDUALS_;
    goto * _jitter_back_to_replicated_code_pointer;
  }
#endif // #ifdef JITTER_REPLICATE

    /* Undefine the !REPLACEMENT-check-in-arity/n4/fR/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1
#   undef JITTER_SLOW_REGISTER_OFFSET2
#   undef JITTER_ARG2
#   undef JITTER_ARGN2
#   undef JITTER_ARGU2
#   undef JITTER_ARGP2
#   undef JITTER_ARGF2

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#ifndef JITTER_REPLICATE
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-check-in-arity/n4/fR/retR, _eREPLACEMENT_mcheck_min_marity__n4__fR__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#endif // #ifndef JITTER_REPLICATE
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for !REPLACEMENT-check-in-arity/n4/fR/retR, which started with its
       definitions. */
  }
#endif // #if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
/*  End of !REPLACEMENT-check-in-arity/n4/fR/retR , a replacement specialised instruction */

  /* Ordinary specialised instruction !REPLACEMENT-check-in-arity/n5/fR/retR (replacement) */
  /* Omit this specialised instruction altogether unless
     replacements are in fact supported in this
     configuration. */
#if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
  JITTER_INSTRUCTION_PROLOG_(!REPLACEMENT-check-in-arity/n5/fR/retR, _eREPLACEMENT_mcheck_min_marity__n5__fR__retR, cold)
  { /* This block begins with definitions for !REPLACEMENT-check-in-arity/n5/fR/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       267
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         !REPLACEMENT-check-in-arity/n5/fR/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "check-in-arity"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "!REPLACEMENT-check-in-arity/n5/fR/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _eREPLACEMENT_mcheck_min_marity__n5__fR__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is non-relocatable.
       Its 2-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST JITTER_BRANCH
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
    /* This specialized instruction is non-relocatable.
       Its 2-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 2

  /* Define argument-access macros for !REPLACEMENT-check-in-arity/n5/fR/retR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 5L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

    /* The 2th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG2  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN2 (JITTER_ARG2.fixnum)
#   define JITTER_ARGU2 (JITTER_ARG2.ufixnum)
#   define JITTER_ARGP2 (JITTER_ARG2.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 5L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

    /* The 2th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG2  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN2 (JITTER_ARG2.fixnum)
#   define JITTER_ARGU2 (JITTER_ARG2.ufixnum)
#   define JITTER_ARGP2 (JITTER_ARG2.pointer)
#   define JITTER_ARGF2 JITTER_ARGP2

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* When jumping to the non-relocatable part it is important not
   to use a fallback version of JITTER_COMPUTED_GOTO, in order to
   prevent GCC from tail-merging. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
    /* Jump to non-relocatable code. */
    JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);

    /* Here the residual arity is given as zero: it's too late to
       skip residuals, since we've already jumped and this code is
       unreachable.  The instruction pointer, if any, is advanced
       in the non-relocatable code. */
    JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-check-in-arity/n5/fR/retR, _eREPLACEMENT_mcheck_min_marity__n5__fR__retR, 0)

    /* Relocated code will jump to this label in non-relocated code. */
  JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
    JITTER_COMMENT_IN_ASM_("!REPLACEMENT-check-in-arity/n5/fR/retR non-relocatable code");
#endif // #ifdef JITTER_REPLICATE
#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of !REPLACEMENT-check-in-arity/n5/fR/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  no. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
//#if 0
  //fprintf (stderr, "Executing instruction %s..\n", "!REPLACEMENT-check-in-arity/n5/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing replacement instruction %s..\n", "!REPLACEMENT-check-in-arity/n5/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing non-relocatable instruction %s with JITTER_SPECIALIZED_INSTRUCTION_WORD_NO=%i..\n", "!REPLACEMENT-check-in-arity/n5/fR/retR", (int) JITTER_SPECIALIZED_INSTRUCTION_WORD_NO); fflush (stderr);
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#undef JITTER_THIS_IS_A_REPLACEMENT
#define JITTER_THIS_IS_A_REPLACEMENT 1

    /* User code for !REPLACEMENT-check-in-arity/n5/fR/retR . */
  {
/* User-specified code, user code block part: beginning. */

#   ifndef JITTERLISP_UNSAFE
      /* Here we can assume that the top object is a closure, without checking:
         we either already performed a type check, or the compiler decided it
         wasn't necessary. */
      jitterlisp_object top = JITTER_TOP_MAINSTACK();
      struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(top);

      JITTER_BRANCH_FAST_IF_NOTEQUAL(c->in_arity, JITTER_ARGN0, JITTER_ARGF1);
#   endif // #ifndef JITTERLISP_UNSAFE
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for !REPLACEMENT-check-in-arity/n5/fR/retR . */

  //fprintf (stderr, "..Executed replacement instruction %s\n", "!REPLACEMENT-check-in-arity/n5/fR/retR");
  //fprintf (stderr, "..Executed instruction %s\n", "!REPLACEMENT-check-in-arity/n5/fR/retR");
//#endif // #if 0
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
#ifdef JITTER_REPLICATE
  {
    /* Advance the instruction pointer, if any, to skip every
       residual but the last; branch back to replicated
       code. */
    const void *_jitter_back_to_replicated_code_pointer =
      JITTER_ARGP2;
    JITTER_SKIP_RESIDUALS_;
    goto * _jitter_back_to_replicated_code_pointer;
  }
#endif // #ifdef JITTER_REPLICATE

    /* Undefine the !REPLACEMENT-check-in-arity/n5/fR/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1
#   undef JITTER_SLOW_REGISTER_OFFSET2
#   undef JITTER_ARG2
#   undef JITTER_ARGN2
#   undef JITTER_ARGU2
#   undef JITTER_ARGP2
#   undef JITTER_ARGF2

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#ifndef JITTER_REPLICATE
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-check-in-arity/n5/fR/retR, _eREPLACEMENT_mcheck_min_marity__n5__fR__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#endif // #ifndef JITTER_REPLICATE
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for !REPLACEMENT-check-in-arity/n5/fR/retR, which started with its
       definitions. */
  }
#endif // #if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
/*  End of !REPLACEMENT-check-in-arity/n5/fR/retR , a replacement specialised instruction */

  /* Ordinary specialised instruction !REPLACEMENT-check-in-arity/n6/fR/retR (replacement) */
  /* Omit this specialised instruction altogether unless
     replacements are in fact supported in this
     configuration. */
#if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
  JITTER_INSTRUCTION_PROLOG_(!REPLACEMENT-check-in-arity/n6/fR/retR, _eREPLACEMENT_mcheck_min_marity__n6__fR__retR, cold)
  { /* This block begins with definitions for !REPLACEMENT-check-in-arity/n6/fR/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       268
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         !REPLACEMENT-check-in-arity/n6/fR/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "check-in-arity"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "!REPLACEMENT-check-in-arity/n6/fR/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _eREPLACEMENT_mcheck_min_marity__n6__fR__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is non-relocatable.
       Its 2-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST JITTER_BRANCH
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
    /* This specialized instruction is non-relocatable.
       Its 2-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 2

  /* Define argument-access macros for !REPLACEMENT-check-in-arity/n6/fR/retR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 6L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

    /* The 2th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG2  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN2 (JITTER_ARG2.fixnum)
#   define JITTER_ARGU2 (JITTER_ARG2.ufixnum)
#   define JITTER_ARGP2 (JITTER_ARG2.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 6L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

    /* The 2th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG2  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN2 (JITTER_ARG2.fixnum)
#   define JITTER_ARGU2 (JITTER_ARG2.ufixnum)
#   define JITTER_ARGP2 (JITTER_ARG2.pointer)
#   define JITTER_ARGF2 JITTER_ARGP2

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* When jumping to the non-relocatable part it is important not
   to use a fallback version of JITTER_COMPUTED_GOTO, in order to
   prevent GCC from tail-merging. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
    /* Jump to non-relocatable code. */
    JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);

    /* Here the residual arity is given as zero: it's too late to
       skip residuals, since we've already jumped and this code is
       unreachable.  The instruction pointer, if any, is advanced
       in the non-relocatable code. */
    JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-check-in-arity/n6/fR/retR, _eREPLACEMENT_mcheck_min_marity__n6__fR__retR, 0)

    /* Relocated code will jump to this label in non-relocated code. */
  JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
    JITTER_COMMENT_IN_ASM_("!REPLACEMENT-check-in-arity/n6/fR/retR non-relocatable code");
#endif // #ifdef JITTER_REPLICATE
#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of !REPLACEMENT-check-in-arity/n6/fR/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  no. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
//#if 0
  //fprintf (stderr, "Executing instruction %s..\n", "!REPLACEMENT-check-in-arity/n6/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing replacement instruction %s..\n", "!REPLACEMENT-check-in-arity/n6/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing non-relocatable instruction %s with JITTER_SPECIALIZED_INSTRUCTION_WORD_NO=%i..\n", "!REPLACEMENT-check-in-arity/n6/fR/retR", (int) JITTER_SPECIALIZED_INSTRUCTION_WORD_NO); fflush (stderr);
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#undef JITTER_THIS_IS_A_REPLACEMENT
#define JITTER_THIS_IS_A_REPLACEMENT 1

    /* User code for !REPLACEMENT-check-in-arity/n6/fR/retR . */
  {
/* User-specified code, user code block part: beginning. */

#   ifndef JITTERLISP_UNSAFE
      /* Here we can assume that the top object is a closure, without checking:
         we either already performed a type check, or the compiler decided it
         wasn't necessary. */
      jitterlisp_object top = JITTER_TOP_MAINSTACK();
      struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(top);

      JITTER_BRANCH_FAST_IF_NOTEQUAL(c->in_arity, JITTER_ARGN0, JITTER_ARGF1);
#   endif // #ifndef JITTERLISP_UNSAFE
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for !REPLACEMENT-check-in-arity/n6/fR/retR . */

  //fprintf (stderr, "..Executed replacement instruction %s\n", "!REPLACEMENT-check-in-arity/n6/fR/retR");
  //fprintf (stderr, "..Executed instruction %s\n", "!REPLACEMENT-check-in-arity/n6/fR/retR");
//#endif // #if 0
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
#ifdef JITTER_REPLICATE
  {
    /* Advance the instruction pointer, if any, to skip every
       residual but the last; branch back to replicated
       code. */
    const void *_jitter_back_to_replicated_code_pointer =
      JITTER_ARGP2;
    JITTER_SKIP_RESIDUALS_;
    goto * _jitter_back_to_replicated_code_pointer;
  }
#endif // #ifdef JITTER_REPLICATE

    /* Undefine the !REPLACEMENT-check-in-arity/n6/fR/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1
#   undef JITTER_SLOW_REGISTER_OFFSET2
#   undef JITTER_ARG2
#   undef JITTER_ARGN2
#   undef JITTER_ARGU2
#   undef JITTER_ARGP2
#   undef JITTER_ARGF2

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#ifndef JITTER_REPLICATE
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-check-in-arity/n6/fR/retR, _eREPLACEMENT_mcheck_min_marity__n6__fR__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#endif // #ifndef JITTER_REPLICATE
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for !REPLACEMENT-check-in-arity/n6/fR/retR, which started with its
       definitions. */
  }
#endif // #if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
/*  End of !REPLACEMENT-check-in-arity/n6/fR/retR , a replacement specialised instruction */

  /* Ordinary specialised instruction !REPLACEMENT-check-in-arity/n7/fR/retR (replacement) */
  /* Omit this specialised instruction altogether unless
     replacements are in fact supported in this
     configuration. */
#if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
  JITTER_INSTRUCTION_PROLOG_(!REPLACEMENT-check-in-arity/n7/fR/retR, _eREPLACEMENT_mcheck_min_marity__n7__fR__retR, cold)
  { /* This block begins with definitions for !REPLACEMENT-check-in-arity/n7/fR/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       269
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         !REPLACEMENT-check-in-arity/n7/fR/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "check-in-arity"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "!REPLACEMENT-check-in-arity/n7/fR/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _eREPLACEMENT_mcheck_min_marity__n7__fR__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is non-relocatable.
       Its 2-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST JITTER_BRANCH
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
    /* This specialized instruction is non-relocatable.
       Its 2-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 2

  /* Define argument-access macros for !REPLACEMENT-check-in-arity/n7/fR/retR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 7L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

    /* The 2th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG2  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN2 (JITTER_ARG2.fixnum)
#   define JITTER_ARGU2 (JITTER_ARG2.ufixnum)
#   define JITTER_ARGP2 (JITTER_ARG2.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 7L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

    /* The 2th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG2  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN2 (JITTER_ARG2.fixnum)
#   define JITTER_ARGU2 (JITTER_ARG2.ufixnum)
#   define JITTER_ARGP2 (JITTER_ARG2.pointer)
#   define JITTER_ARGF2 JITTER_ARGP2

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* When jumping to the non-relocatable part it is important not
   to use a fallback version of JITTER_COMPUTED_GOTO, in order to
   prevent GCC from tail-merging. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
    /* Jump to non-relocatable code. */
    JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);

    /* Here the residual arity is given as zero: it's too late to
       skip residuals, since we've already jumped and this code is
       unreachable.  The instruction pointer, if any, is advanced
       in the non-relocatable code. */
    JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-check-in-arity/n7/fR/retR, _eREPLACEMENT_mcheck_min_marity__n7__fR__retR, 0)

    /* Relocated code will jump to this label in non-relocated code. */
  JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
    JITTER_COMMENT_IN_ASM_("!REPLACEMENT-check-in-arity/n7/fR/retR non-relocatable code");
#endif // #ifdef JITTER_REPLICATE
#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of !REPLACEMENT-check-in-arity/n7/fR/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  no. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
//#if 0
  //fprintf (stderr, "Executing instruction %s..\n", "!REPLACEMENT-check-in-arity/n7/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing replacement instruction %s..\n", "!REPLACEMENT-check-in-arity/n7/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing non-relocatable instruction %s with JITTER_SPECIALIZED_INSTRUCTION_WORD_NO=%i..\n", "!REPLACEMENT-check-in-arity/n7/fR/retR", (int) JITTER_SPECIALIZED_INSTRUCTION_WORD_NO); fflush (stderr);
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#undef JITTER_THIS_IS_A_REPLACEMENT
#define JITTER_THIS_IS_A_REPLACEMENT 1

    /* User code for !REPLACEMENT-check-in-arity/n7/fR/retR . */
  {
/* User-specified code, user code block part: beginning. */

#   ifndef JITTERLISP_UNSAFE
      /* Here we can assume that the top object is a closure, without checking:
         we either already performed a type check, or the compiler decided it
         wasn't necessary. */
      jitterlisp_object top = JITTER_TOP_MAINSTACK();
      struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(top);

      JITTER_BRANCH_FAST_IF_NOTEQUAL(c->in_arity, JITTER_ARGN0, JITTER_ARGF1);
#   endif // #ifndef JITTERLISP_UNSAFE
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for !REPLACEMENT-check-in-arity/n7/fR/retR . */

  //fprintf (stderr, "..Executed replacement instruction %s\n", "!REPLACEMENT-check-in-arity/n7/fR/retR");
  //fprintf (stderr, "..Executed instruction %s\n", "!REPLACEMENT-check-in-arity/n7/fR/retR");
//#endif // #if 0
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
#ifdef JITTER_REPLICATE
  {
    /* Advance the instruction pointer, if any, to skip every
       residual but the last; branch back to replicated
       code. */
    const void *_jitter_back_to_replicated_code_pointer =
      JITTER_ARGP2;
    JITTER_SKIP_RESIDUALS_;
    goto * _jitter_back_to_replicated_code_pointer;
  }
#endif // #ifdef JITTER_REPLICATE

    /* Undefine the !REPLACEMENT-check-in-arity/n7/fR/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1
#   undef JITTER_SLOW_REGISTER_OFFSET2
#   undef JITTER_ARG2
#   undef JITTER_ARGN2
#   undef JITTER_ARGU2
#   undef JITTER_ARGP2
#   undef JITTER_ARGF2

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#ifndef JITTER_REPLICATE
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-check-in-arity/n7/fR/retR, _eREPLACEMENT_mcheck_min_marity__n7__fR__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#endif // #ifndef JITTER_REPLICATE
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for !REPLACEMENT-check-in-arity/n7/fR/retR, which started with its
       definitions. */
  }
#endif // #if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
/*  End of !REPLACEMENT-check-in-arity/n7/fR/retR , a replacement specialised instruction */

  /* Ordinary specialised instruction !REPLACEMENT-check-in-arity/n8/fR/retR (replacement) */
  /* Omit this specialised instruction altogether unless
     replacements are in fact supported in this
     configuration. */
#if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
  JITTER_INSTRUCTION_PROLOG_(!REPLACEMENT-check-in-arity/n8/fR/retR, _eREPLACEMENT_mcheck_min_marity__n8__fR__retR, cold)
  { /* This block begins with definitions for !REPLACEMENT-check-in-arity/n8/fR/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       270
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         !REPLACEMENT-check-in-arity/n8/fR/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "check-in-arity"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "!REPLACEMENT-check-in-arity/n8/fR/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _eREPLACEMENT_mcheck_min_marity__n8__fR__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is non-relocatable.
       Its 2-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST JITTER_BRANCH
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
    /* This specialized instruction is non-relocatable.
       Its 2-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 2

  /* Define argument-access macros for !REPLACEMENT-check-in-arity/n8/fR/retR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 8L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

    /* The 2th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG2  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN2 (JITTER_ARG2.fixnum)
#   define JITTER_ARGU2 (JITTER_ARG2.ufixnum)
#   define JITTER_ARGP2 (JITTER_ARG2.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 8L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

    /* The 2th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG2  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN2 (JITTER_ARG2.fixnum)
#   define JITTER_ARGU2 (JITTER_ARG2.ufixnum)
#   define JITTER_ARGP2 (JITTER_ARG2.pointer)
#   define JITTER_ARGF2 JITTER_ARGP2

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* When jumping to the non-relocatable part it is important not
   to use a fallback version of JITTER_COMPUTED_GOTO, in order to
   prevent GCC from tail-merging. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
    /* Jump to non-relocatable code. */
    JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);

    /* Here the residual arity is given as zero: it's too late to
       skip residuals, since we've already jumped and this code is
       unreachable.  The instruction pointer, if any, is advanced
       in the non-relocatable code. */
    JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-check-in-arity/n8/fR/retR, _eREPLACEMENT_mcheck_min_marity__n8__fR__retR, 0)

    /* Relocated code will jump to this label in non-relocated code. */
  JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
    JITTER_COMMENT_IN_ASM_("!REPLACEMENT-check-in-arity/n8/fR/retR non-relocatable code");
#endif // #ifdef JITTER_REPLICATE
#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of !REPLACEMENT-check-in-arity/n8/fR/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  no. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
//#if 0
  //fprintf (stderr, "Executing instruction %s..\n", "!REPLACEMENT-check-in-arity/n8/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing replacement instruction %s..\n", "!REPLACEMENT-check-in-arity/n8/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing non-relocatable instruction %s with JITTER_SPECIALIZED_INSTRUCTION_WORD_NO=%i..\n", "!REPLACEMENT-check-in-arity/n8/fR/retR", (int) JITTER_SPECIALIZED_INSTRUCTION_WORD_NO); fflush (stderr);
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#undef JITTER_THIS_IS_A_REPLACEMENT
#define JITTER_THIS_IS_A_REPLACEMENT 1

    /* User code for !REPLACEMENT-check-in-arity/n8/fR/retR . */
  {
/* User-specified code, user code block part: beginning. */

#   ifndef JITTERLISP_UNSAFE
      /* Here we can assume that the top object is a closure, without checking:
         we either already performed a type check, or the compiler decided it
         wasn't necessary. */
      jitterlisp_object top = JITTER_TOP_MAINSTACK();
      struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(top);

      JITTER_BRANCH_FAST_IF_NOTEQUAL(c->in_arity, JITTER_ARGN0, JITTER_ARGF1);
#   endif // #ifndef JITTERLISP_UNSAFE
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for !REPLACEMENT-check-in-arity/n8/fR/retR . */

  //fprintf (stderr, "..Executed replacement instruction %s\n", "!REPLACEMENT-check-in-arity/n8/fR/retR");
  //fprintf (stderr, "..Executed instruction %s\n", "!REPLACEMENT-check-in-arity/n8/fR/retR");
//#endif // #if 0
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
#ifdef JITTER_REPLICATE
  {
    /* Advance the instruction pointer, if any, to skip every
       residual but the last; branch back to replicated
       code. */
    const void *_jitter_back_to_replicated_code_pointer =
      JITTER_ARGP2;
    JITTER_SKIP_RESIDUALS_;
    goto * _jitter_back_to_replicated_code_pointer;
  }
#endif // #ifdef JITTER_REPLICATE

    /* Undefine the !REPLACEMENT-check-in-arity/n8/fR/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1
#   undef JITTER_SLOW_REGISTER_OFFSET2
#   undef JITTER_ARG2
#   undef JITTER_ARGN2
#   undef JITTER_ARGU2
#   undef JITTER_ARGP2
#   undef JITTER_ARGF2

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#ifndef JITTER_REPLICATE
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-check-in-arity/n8/fR/retR, _eREPLACEMENT_mcheck_min_marity__n8__fR__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#endif // #ifndef JITTER_REPLICATE
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for !REPLACEMENT-check-in-arity/n8/fR/retR, which started with its
       definitions. */
  }
#endif // #if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
/*  End of !REPLACEMENT-check-in-arity/n8/fR/retR , a replacement specialised instruction */

  /* Ordinary specialised instruction !REPLACEMENT-check-in-arity/n9/fR/retR (replacement) */
  /* Omit this specialised instruction altogether unless
     replacements are in fact supported in this
     configuration. */
#if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
  JITTER_INSTRUCTION_PROLOG_(!REPLACEMENT-check-in-arity/n9/fR/retR, _eREPLACEMENT_mcheck_min_marity__n9__fR__retR, cold)
  { /* This block begins with definitions for !REPLACEMENT-check-in-arity/n9/fR/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       271
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         !REPLACEMENT-check-in-arity/n9/fR/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "check-in-arity"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "!REPLACEMENT-check-in-arity/n9/fR/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _eREPLACEMENT_mcheck_min_marity__n9__fR__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is non-relocatable.
       Its 2-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST JITTER_BRANCH
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
    /* This specialized instruction is non-relocatable.
       Its 2-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 2

  /* Define argument-access macros for !REPLACEMENT-check-in-arity/n9/fR/retR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 9L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

    /* The 2th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG2  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN2 (JITTER_ARG2.fixnum)
#   define JITTER_ARGU2 (JITTER_ARG2.ufixnum)
#   define JITTER_ARGP2 (JITTER_ARG2.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 9L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

    /* The 2th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG2  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN2 (JITTER_ARG2.fixnum)
#   define JITTER_ARGU2 (JITTER_ARG2.ufixnum)
#   define JITTER_ARGP2 (JITTER_ARG2.pointer)
#   define JITTER_ARGF2 JITTER_ARGP2

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* When jumping to the non-relocatable part it is important not
   to use a fallback version of JITTER_COMPUTED_GOTO, in order to
   prevent GCC from tail-merging. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
    /* Jump to non-relocatable code. */
    JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);

    /* Here the residual arity is given as zero: it's too late to
       skip residuals, since we've already jumped and this code is
       unreachable.  The instruction pointer, if any, is advanced
       in the non-relocatable code. */
    JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-check-in-arity/n9/fR/retR, _eREPLACEMENT_mcheck_min_marity__n9__fR__retR, 0)

    /* Relocated code will jump to this label in non-relocated code. */
  JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
    JITTER_COMMENT_IN_ASM_("!REPLACEMENT-check-in-arity/n9/fR/retR non-relocatable code");
#endif // #ifdef JITTER_REPLICATE
#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of !REPLACEMENT-check-in-arity/n9/fR/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  no. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
//#if 0
  //fprintf (stderr, "Executing instruction %s..\n", "!REPLACEMENT-check-in-arity/n9/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing replacement instruction %s..\n", "!REPLACEMENT-check-in-arity/n9/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing non-relocatable instruction %s with JITTER_SPECIALIZED_INSTRUCTION_WORD_NO=%i..\n", "!REPLACEMENT-check-in-arity/n9/fR/retR", (int) JITTER_SPECIALIZED_INSTRUCTION_WORD_NO); fflush (stderr);
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#undef JITTER_THIS_IS_A_REPLACEMENT
#define JITTER_THIS_IS_A_REPLACEMENT 1

    /* User code for !REPLACEMENT-check-in-arity/n9/fR/retR . */
  {
/* User-specified code, user code block part: beginning. */

#   ifndef JITTERLISP_UNSAFE
      /* Here we can assume that the top object is a closure, without checking:
         we either already performed a type check, or the compiler decided it
         wasn't necessary. */
      jitterlisp_object top = JITTER_TOP_MAINSTACK();
      struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(top);

      JITTER_BRANCH_FAST_IF_NOTEQUAL(c->in_arity, JITTER_ARGN0, JITTER_ARGF1);
#   endif // #ifndef JITTERLISP_UNSAFE
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for !REPLACEMENT-check-in-arity/n9/fR/retR . */

  //fprintf (stderr, "..Executed replacement instruction %s\n", "!REPLACEMENT-check-in-arity/n9/fR/retR");
  //fprintf (stderr, "..Executed instruction %s\n", "!REPLACEMENT-check-in-arity/n9/fR/retR");
//#endif // #if 0
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
#ifdef JITTER_REPLICATE
  {
    /* Advance the instruction pointer, if any, to skip every
       residual but the last; branch back to replicated
       code. */
    const void *_jitter_back_to_replicated_code_pointer =
      JITTER_ARGP2;
    JITTER_SKIP_RESIDUALS_;
    goto * _jitter_back_to_replicated_code_pointer;
  }
#endif // #ifdef JITTER_REPLICATE

    /* Undefine the !REPLACEMENT-check-in-arity/n9/fR/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1
#   undef JITTER_SLOW_REGISTER_OFFSET2
#   undef JITTER_ARG2
#   undef JITTER_ARGN2
#   undef JITTER_ARGU2
#   undef JITTER_ARGP2
#   undef JITTER_ARGF2

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#ifndef JITTER_REPLICATE
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-check-in-arity/n9/fR/retR, _eREPLACEMENT_mcheck_min_marity__n9__fR__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#endif // #ifndef JITTER_REPLICATE
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for !REPLACEMENT-check-in-arity/n9/fR/retR, which started with its
       definitions. */
  }
#endif // #if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
/*  End of !REPLACEMENT-check-in-arity/n9/fR/retR , a replacement specialised instruction */

  /* Ordinary specialised instruction !REPLACEMENT-check-in-arity/n10/fR/retR (replacement) */
  /* Omit this specialised instruction altogether unless
     replacements are in fact supported in this
     configuration. */
#if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
  JITTER_INSTRUCTION_PROLOG_(!REPLACEMENT-check-in-arity/n10/fR/retR, _eREPLACEMENT_mcheck_min_marity__n10__fR__retR, cold)
  { /* This block begins with definitions for !REPLACEMENT-check-in-arity/n10/fR/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       272
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         !REPLACEMENT-check-in-arity/n10/fR/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "check-in-arity"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "!REPLACEMENT-check-in-arity/n10/fR/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _eREPLACEMENT_mcheck_min_marity__n10__fR__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is non-relocatable.
       Its 2-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST JITTER_BRANCH
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
    /* This specialized instruction is non-relocatable.
       Its 2-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 2

  /* Define argument-access macros for !REPLACEMENT-check-in-arity/n10/fR/retR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 10L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

    /* The 2th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG2  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN2 (JITTER_ARG2.fixnum)
#   define JITTER_ARGU2 (JITTER_ARG2.ufixnum)
#   define JITTER_ARGP2 (JITTER_ARG2.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 10L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

    /* The 2th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG2  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN2 (JITTER_ARG2.fixnum)
#   define JITTER_ARGU2 (JITTER_ARG2.ufixnum)
#   define JITTER_ARGP2 (JITTER_ARG2.pointer)
#   define JITTER_ARGF2 JITTER_ARGP2

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* When jumping to the non-relocatable part it is important not
   to use a fallback version of JITTER_COMPUTED_GOTO, in order to
   prevent GCC from tail-merging. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
    /* Jump to non-relocatable code. */
    JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);

    /* Here the residual arity is given as zero: it's too late to
       skip residuals, since we've already jumped and this code is
       unreachable.  The instruction pointer, if any, is advanced
       in the non-relocatable code. */
    JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-check-in-arity/n10/fR/retR, _eREPLACEMENT_mcheck_min_marity__n10__fR__retR, 0)

    /* Relocated code will jump to this label in non-relocated code. */
  JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
    JITTER_COMMENT_IN_ASM_("!REPLACEMENT-check-in-arity/n10/fR/retR non-relocatable code");
#endif // #ifdef JITTER_REPLICATE
#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of !REPLACEMENT-check-in-arity/n10/fR/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  no. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
//#if 0
  //fprintf (stderr, "Executing instruction %s..\n", "!REPLACEMENT-check-in-arity/n10/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing replacement instruction %s..\n", "!REPLACEMENT-check-in-arity/n10/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing non-relocatable instruction %s with JITTER_SPECIALIZED_INSTRUCTION_WORD_NO=%i..\n", "!REPLACEMENT-check-in-arity/n10/fR/retR", (int) JITTER_SPECIALIZED_INSTRUCTION_WORD_NO); fflush (stderr);
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#undef JITTER_THIS_IS_A_REPLACEMENT
#define JITTER_THIS_IS_A_REPLACEMENT 1

    /* User code for !REPLACEMENT-check-in-arity/n10/fR/retR . */
  {
/* User-specified code, user code block part: beginning. */

#   ifndef JITTERLISP_UNSAFE
      /* Here we can assume that the top object is a closure, without checking:
         we either already performed a type check, or the compiler decided it
         wasn't necessary. */
      jitterlisp_object top = JITTER_TOP_MAINSTACK();
      struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(top);

      JITTER_BRANCH_FAST_IF_NOTEQUAL(c->in_arity, JITTER_ARGN0, JITTER_ARGF1);
#   endif // #ifndef JITTERLISP_UNSAFE
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for !REPLACEMENT-check-in-arity/n10/fR/retR . */

  //fprintf (stderr, "..Executed replacement instruction %s\n", "!REPLACEMENT-check-in-arity/n10/fR/retR");
  //fprintf (stderr, "..Executed instruction %s\n", "!REPLACEMENT-check-in-arity/n10/fR/retR");
//#endif // #if 0
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
#ifdef JITTER_REPLICATE
  {
    /* Advance the instruction pointer, if any, to skip every
       residual but the last; branch back to replicated
       code. */
    const void *_jitter_back_to_replicated_code_pointer =
      JITTER_ARGP2;
    JITTER_SKIP_RESIDUALS_;
    goto * _jitter_back_to_replicated_code_pointer;
  }
#endif // #ifdef JITTER_REPLICATE

    /* Undefine the !REPLACEMENT-check-in-arity/n10/fR/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1
#   undef JITTER_SLOW_REGISTER_OFFSET2
#   undef JITTER_ARG2
#   undef JITTER_ARGN2
#   undef JITTER_ARGU2
#   undef JITTER_ARGP2
#   undef JITTER_ARGF2

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#ifndef JITTER_REPLICATE
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-check-in-arity/n10/fR/retR, _eREPLACEMENT_mcheck_min_marity__n10__fR__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#endif // #ifndef JITTER_REPLICATE
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for !REPLACEMENT-check-in-arity/n10/fR/retR, which started with its
       definitions. */
  }
#endif // #if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
/*  End of !REPLACEMENT-check-in-arity/n10/fR/retR , a replacement specialised instruction */

  /* Ordinary specialised instruction !REPLACEMENT-check-in-arity/nR/fR/retR (replacement) */
  /* Omit this specialised instruction altogether unless
     replacements are in fact supported in this
     configuration. */
#if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
  JITTER_INSTRUCTION_PROLOG_(!REPLACEMENT-check-in-arity/nR/fR/retR, _eREPLACEMENT_mcheck_min_marity__nR__fR__retR, cold)
  { /* This block begins with definitions for !REPLACEMENT-check-in-arity/nR/fR/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       273
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         !REPLACEMENT-check-in-arity/nR/fR/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "check-in-arity"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "!REPLACEMENT-check-in-arity/nR/fR/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _eREPLACEMENT_mcheck_min_marity__nR__fR__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is non-relocatable.
       Its 2-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST JITTER_BRANCH
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
    /* This specialized instruction is non-relocatable.
       Its 2-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 3

  /* Define argument-access macros for !REPLACEMENT-check-in-arity/nR/fR/retR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a residual literal. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

    /* The 2th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG2  JITTER_RESIDUAL_ARGUMENT_2
    JITTER_MARK_RESIDUAL_2_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[2])
#else
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[3])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN2 (JITTER_ARG2.fixnum)
#   define JITTER_ARGU2 (JITTER_ARG2.ufixnum)
#   define JITTER_ARGP2 (JITTER_ARG2.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
    /* The 0th argument is a residual literal. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

    /* The 2th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG2  JITTER_RESIDUAL_ARGUMENT_2
    JITTER_MARK_RESIDUAL_2_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[2])
#else
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[3])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN2 (JITTER_ARG2.fixnum)
#   define JITTER_ARGU2 (JITTER_ARG2.ufixnum)
#   define JITTER_ARGP2 (JITTER_ARG2.pointer)
#   define JITTER_ARGF2 JITTER_ARGP2

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* When jumping to the non-relocatable part it is important not
   to use a fallback version of JITTER_COMPUTED_GOTO, in order to
   prevent GCC from tail-merging. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
    /* Jump to non-relocatable code. */
    JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);

    /* Here the residual arity is given as zero: it's too late to
       skip residuals, since we've already jumped and this code is
       unreachable.  The instruction pointer, if any, is advanced
       in the non-relocatable code. */
    JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-check-in-arity/nR/fR/retR, _eREPLACEMENT_mcheck_min_marity__nR__fR__retR, 0)

    /* Relocated code will jump to this label in non-relocated code. */
  JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
    JITTER_COMMENT_IN_ASM_("!REPLACEMENT-check-in-arity/nR/fR/retR non-relocatable code");
#endif // #ifdef JITTER_REPLICATE
#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of !REPLACEMENT-check-in-arity/nR/fR/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  no. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
//#if 0
  //fprintf (stderr, "Executing instruction %s..\n", "!REPLACEMENT-check-in-arity/nR/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing replacement instruction %s..\n", "!REPLACEMENT-check-in-arity/nR/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing non-relocatable instruction %s with JITTER_SPECIALIZED_INSTRUCTION_WORD_NO=%i..\n", "!REPLACEMENT-check-in-arity/nR/fR/retR", (int) JITTER_SPECIALIZED_INSTRUCTION_WORD_NO); fflush (stderr);
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#undef JITTER_THIS_IS_A_REPLACEMENT
#define JITTER_THIS_IS_A_REPLACEMENT 1

    /* User code for !REPLACEMENT-check-in-arity/nR/fR/retR . */
  {
/* User-specified code, user code block part: beginning. */

#   ifndef JITTERLISP_UNSAFE
      /* Here we can assume that the top object is a closure, without checking:
         we either already performed a type check, or the compiler decided it
         wasn't necessary. */
      jitterlisp_object top = JITTER_TOP_MAINSTACK();
      struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(top);

      JITTER_BRANCH_FAST_IF_NOTEQUAL(c->in_arity, JITTER_ARGN0, JITTER_ARGF1);
#   endif // #ifndef JITTERLISP_UNSAFE
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for !REPLACEMENT-check-in-arity/nR/fR/retR . */

  //fprintf (stderr, "..Executed replacement instruction %s\n", "!REPLACEMENT-check-in-arity/nR/fR/retR");
  //fprintf (stderr, "..Executed instruction %s\n", "!REPLACEMENT-check-in-arity/nR/fR/retR");
//#endif // #if 0
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
#ifdef JITTER_REPLICATE
  {
    /* Advance the instruction pointer, if any, to skip every
       residual but the last; branch back to replicated
       code. */
    const void *_jitter_back_to_replicated_code_pointer =
      JITTER_ARGP2;
    JITTER_SKIP_RESIDUALS_;
    goto * _jitter_back_to_replicated_code_pointer;
  }
#endif // #ifdef JITTER_REPLICATE

    /* Undefine the !REPLACEMENT-check-in-arity/nR/fR/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1
#   undef JITTER_SLOW_REGISTER_OFFSET2
#   undef JITTER_ARG2
#   undef JITTER_ARGN2
#   undef JITTER_ARGU2
#   undef JITTER_ARGP2
#   undef JITTER_ARGF2

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#ifndef JITTER_REPLICATE
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-check-in-arity/nR/fR/retR, _eREPLACEMENT_mcheck_min_marity__nR__fR__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#endif // #ifndef JITTER_REPLICATE
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for !REPLACEMENT-check-in-arity/nR/fR/retR, which started with its
       definitions. */
  }
#endif // #if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
/*  End of !REPLACEMENT-check-in-arity/nR/fR/retR , a replacement specialised instruction */

  /* Ordinary specialised instruction !REPLACEMENT-check-in-arity--alt/n0/fR/retR (replacement) */
  /* Omit this specialised instruction altogether unless
     replacements are in fact supported in this
     configuration. */
#if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
  JITTER_INSTRUCTION_PROLOG_(!REPLACEMENT-check-in-arity--alt/n0/fR/retR, _eREPLACEMENT_mcheck_min_marity_m_malt__n0__fR__retR, cold)
  { /* This block begins with definitions for !REPLACEMENT-check-in-arity--alt/n0/fR/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       274
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         !REPLACEMENT-check-in-arity--alt/n0/fR/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "check-in-arity--alt"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "!REPLACEMENT-check-in-arity--alt/n0/fR/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _eREPLACEMENT_mcheck_min_marity_m_malt__n0__fR__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is non-relocatable.
       Its 2-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST JITTER_BRANCH
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
    /* This specialized instruction is non-relocatable.
       Its 2-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 2

  /* Define argument-access macros for !REPLACEMENT-check-in-arity--alt/n0/fR/retR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 0L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

    /* The 2th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG2  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN2 (JITTER_ARG2.fixnum)
#   define JITTER_ARGU2 (JITTER_ARG2.ufixnum)
#   define JITTER_ARGP2 (JITTER_ARG2.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 0L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

    /* The 2th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG2  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN2 (JITTER_ARG2.fixnum)
#   define JITTER_ARGU2 (JITTER_ARG2.ufixnum)
#   define JITTER_ARGP2 (JITTER_ARG2.pointer)
#   define JITTER_ARGF2 JITTER_ARGP2

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* When jumping to the non-relocatable part it is important not
   to use a fallback version of JITTER_COMPUTED_GOTO, in order to
   prevent GCC from tail-merging. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
    /* Jump to non-relocatable code. */
    JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);

    /* Here the residual arity is given as zero: it's too late to
       skip residuals, since we've already jumped and this code is
       unreachable.  The instruction pointer, if any, is advanced
       in the non-relocatable code. */
    JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-check-in-arity--alt/n0/fR/retR, _eREPLACEMENT_mcheck_min_marity_m_malt__n0__fR__retR, 0)

    /* Relocated code will jump to this label in non-relocated code. */
  JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
    JITTER_COMMENT_IN_ASM_("!REPLACEMENT-check-in-arity--alt/n0/fR/retR non-relocatable code");
#endif // #ifdef JITTER_REPLICATE
#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of !REPLACEMENT-check-in-arity--alt/n0/fR/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  no. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
//#if 0
  //fprintf (stderr, "Executing instruction %s..\n", "!REPLACEMENT-check-in-arity--alt/n0/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing replacement instruction %s..\n", "!REPLACEMENT-check-in-arity--alt/n0/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing non-relocatable instruction %s with JITTER_SPECIALIZED_INSTRUCTION_WORD_NO=%i..\n", "!REPLACEMENT-check-in-arity--alt/n0/fR/retR", (int) JITTER_SPECIALIZED_INSTRUCTION_WORD_NO); fflush (stderr);
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#undef JITTER_THIS_IS_A_REPLACEMENT
#define JITTER_THIS_IS_A_REPLACEMENT 1

    /* User code for !REPLACEMENT-check-in-arity--alt/n0/fR/retR . */
  {
/* User-specified code, user code block part: beginning. */

    // FIXME: this loops forever with no-threading (not with the other dispatches
    // including minimal threading) when the callee is compiled.  A Jitter bug.
    /* Here we can assume that the top object is a closure, without checking: we either
       already performed a type check, or the compiler decided it wasn't necessary. */
    jitterlisp_object top = JITTER_TOP_MAINSTACK();
    struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(top);

    /* FIXME: this is optimizable.  I should store the in-arity as a field, independently
       from the closure compiledness.  [Done] */
    if (JITTERLISP_IS_COMPILED_CLOSURE(top))
      {
        if (c->in_arity != JITTER_ARGN0)
          JITTER_BRANCH_FAST(JITTER_ARGF1);
      }
    else
      {
        /* The closure is interpreted.  Compute its in-arity.  We can assume that
           the formal list is well-formal, which is to say actually a proper list
           of distinct symbols. */
        struct jitterlisp_interpreted_closure *ic = & c->interpreted;
        jitterlisp_object rest = ic->formals;
        jitter_uint in_arity = 0;
        while (! JITTERLISP_IS_EMPTY_LIST(rest))
          {
            in_arity ++;
            rest = JITTERLISP_EXP_C_A_CDR(rest);
          }
        if (in_arity != JITTER_ARGN0)
          JITTER_BRANCH_FAST(JITTER_ARGF1);
      }
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for !REPLACEMENT-check-in-arity--alt/n0/fR/retR . */

  //fprintf (stderr, "..Executed replacement instruction %s\n", "!REPLACEMENT-check-in-arity--alt/n0/fR/retR");
  //fprintf (stderr, "..Executed instruction %s\n", "!REPLACEMENT-check-in-arity--alt/n0/fR/retR");
//#endif // #if 0
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
#ifdef JITTER_REPLICATE
  {
    /* Advance the instruction pointer, if any, to skip every
       residual but the last; branch back to replicated
       code. */
    const void *_jitter_back_to_replicated_code_pointer =
      JITTER_ARGP2;
    JITTER_SKIP_RESIDUALS_;
    goto * _jitter_back_to_replicated_code_pointer;
  }
#endif // #ifdef JITTER_REPLICATE

    /* Undefine the !REPLACEMENT-check-in-arity--alt/n0/fR/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1
#   undef JITTER_SLOW_REGISTER_OFFSET2
#   undef JITTER_ARG2
#   undef JITTER_ARGN2
#   undef JITTER_ARGU2
#   undef JITTER_ARGP2
#   undef JITTER_ARGF2

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#ifndef JITTER_REPLICATE
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-check-in-arity--alt/n0/fR/retR, _eREPLACEMENT_mcheck_min_marity_m_malt__n0__fR__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#endif // #ifndef JITTER_REPLICATE
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for !REPLACEMENT-check-in-arity--alt/n0/fR/retR, which started with its
       definitions. */
  }
#endif // #if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
/*  End of !REPLACEMENT-check-in-arity--alt/n0/fR/retR , a replacement specialised instruction */

  /* Ordinary specialised instruction !REPLACEMENT-check-in-arity--alt/n1/fR/retR (replacement) */
  /* Omit this specialised instruction altogether unless
     replacements are in fact supported in this
     configuration. */
#if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
  JITTER_INSTRUCTION_PROLOG_(!REPLACEMENT-check-in-arity--alt/n1/fR/retR, _eREPLACEMENT_mcheck_min_marity_m_malt__n1__fR__retR, cold)
  { /* This block begins with definitions for !REPLACEMENT-check-in-arity--alt/n1/fR/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       275
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         !REPLACEMENT-check-in-arity--alt/n1/fR/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "check-in-arity--alt"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "!REPLACEMENT-check-in-arity--alt/n1/fR/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _eREPLACEMENT_mcheck_min_marity_m_malt__n1__fR__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is non-relocatable.
       Its 2-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST JITTER_BRANCH
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
    /* This specialized instruction is non-relocatable.
       Its 2-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 2

  /* Define argument-access macros for !REPLACEMENT-check-in-arity--alt/n1/fR/retR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 1L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

    /* The 2th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG2  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN2 (JITTER_ARG2.fixnum)
#   define JITTER_ARGU2 (JITTER_ARG2.ufixnum)
#   define JITTER_ARGP2 (JITTER_ARG2.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 1L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

    /* The 2th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG2  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN2 (JITTER_ARG2.fixnum)
#   define JITTER_ARGU2 (JITTER_ARG2.ufixnum)
#   define JITTER_ARGP2 (JITTER_ARG2.pointer)
#   define JITTER_ARGF2 JITTER_ARGP2

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* When jumping to the non-relocatable part it is important not
   to use a fallback version of JITTER_COMPUTED_GOTO, in order to
   prevent GCC from tail-merging. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
    /* Jump to non-relocatable code. */
    JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);

    /* Here the residual arity is given as zero: it's too late to
       skip residuals, since we've already jumped and this code is
       unreachable.  The instruction pointer, if any, is advanced
       in the non-relocatable code. */
    JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-check-in-arity--alt/n1/fR/retR, _eREPLACEMENT_mcheck_min_marity_m_malt__n1__fR__retR, 0)

    /* Relocated code will jump to this label in non-relocated code. */
  JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
    JITTER_COMMENT_IN_ASM_("!REPLACEMENT-check-in-arity--alt/n1/fR/retR non-relocatable code");
#endif // #ifdef JITTER_REPLICATE
#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of !REPLACEMENT-check-in-arity--alt/n1/fR/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  no. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
//#if 0
  //fprintf (stderr, "Executing instruction %s..\n", "!REPLACEMENT-check-in-arity--alt/n1/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing replacement instruction %s..\n", "!REPLACEMENT-check-in-arity--alt/n1/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing non-relocatable instruction %s with JITTER_SPECIALIZED_INSTRUCTION_WORD_NO=%i..\n", "!REPLACEMENT-check-in-arity--alt/n1/fR/retR", (int) JITTER_SPECIALIZED_INSTRUCTION_WORD_NO); fflush (stderr);
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#undef JITTER_THIS_IS_A_REPLACEMENT
#define JITTER_THIS_IS_A_REPLACEMENT 1

    /* User code for !REPLACEMENT-check-in-arity--alt/n1/fR/retR . */
  {
/* User-specified code, user code block part: beginning. */

    // FIXME: this loops forever with no-threading (not with the other dispatches
    // including minimal threading) when the callee is compiled.  A Jitter bug.
    /* Here we can assume that the top object is a closure, without checking: we either
       already performed a type check, or the compiler decided it wasn't necessary. */
    jitterlisp_object top = JITTER_TOP_MAINSTACK();
    struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(top);

    /* FIXME: this is optimizable.  I should store the in-arity as a field, independently
       from the closure compiledness.  [Done] */
    if (JITTERLISP_IS_COMPILED_CLOSURE(top))
      {
        if (c->in_arity != JITTER_ARGN0)
          JITTER_BRANCH_FAST(JITTER_ARGF1);
      }
    else
      {
        /* The closure is interpreted.  Compute its in-arity.  We can assume that
           the formal list is well-formal, which is to say actually a proper list
           of distinct symbols. */
        struct jitterlisp_interpreted_closure *ic = & c->interpreted;
        jitterlisp_object rest = ic->formals;
        jitter_uint in_arity = 0;
        while (! JITTERLISP_IS_EMPTY_LIST(rest))
          {
            in_arity ++;
            rest = JITTERLISP_EXP_C_A_CDR(rest);
          }
        if (in_arity != JITTER_ARGN0)
          JITTER_BRANCH_FAST(JITTER_ARGF1);
      }
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for !REPLACEMENT-check-in-arity--alt/n1/fR/retR . */

  //fprintf (stderr, "..Executed replacement instruction %s\n", "!REPLACEMENT-check-in-arity--alt/n1/fR/retR");
  //fprintf (stderr, "..Executed instruction %s\n", "!REPLACEMENT-check-in-arity--alt/n1/fR/retR");
//#endif // #if 0
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
#ifdef JITTER_REPLICATE
  {
    /* Advance the instruction pointer, if any, to skip every
       residual but the last; branch back to replicated
       code. */
    const void *_jitter_back_to_replicated_code_pointer =
      JITTER_ARGP2;
    JITTER_SKIP_RESIDUALS_;
    goto * _jitter_back_to_replicated_code_pointer;
  }
#endif // #ifdef JITTER_REPLICATE

    /* Undefine the !REPLACEMENT-check-in-arity--alt/n1/fR/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1
#   undef JITTER_SLOW_REGISTER_OFFSET2
#   undef JITTER_ARG2
#   undef JITTER_ARGN2
#   undef JITTER_ARGU2
#   undef JITTER_ARGP2
#   undef JITTER_ARGF2

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#ifndef JITTER_REPLICATE
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-check-in-arity--alt/n1/fR/retR, _eREPLACEMENT_mcheck_min_marity_m_malt__n1__fR__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#endif // #ifndef JITTER_REPLICATE
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for !REPLACEMENT-check-in-arity--alt/n1/fR/retR, which started with its
       definitions. */
  }
#endif // #if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
/*  End of !REPLACEMENT-check-in-arity--alt/n1/fR/retR , a replacement specialised instruction */

  /* Ordinary specialised instruction !REPLACEMENT-check-in-arity--alt/n2/fR/retR (replacement) */
  /* Omit this specialised instruction altogether unless
     replacements are in fact supported in this
     configuration. */
#if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
  JITTER_INSTRUCTION_PROLOG_(!REPLACEMENT-check-in-arity--alt/n2/fR/retR, _eREPLACEMENT_mcheck_min_marity_m_malt__n2__fR__retR, cold)
  { /* This block begins with definitions for !REPLACEMENT-check-in-arity--alt/n2/fR/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       276
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         !REPLACEMENT-check-in-arity--alt/n2/fR/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "check-in-arity--alt"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "!REPLACEMENT-check-in-arity--alt/n2/fR/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _eREPLACEMENT_mcheck_min_marity_m_malt__n2__fR__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is non-relocatable.
       Its 2-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST JITTER_BRANCH
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
    /* This specialized instruction is non-relocatable.
       Its 2-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 2

  /* Define argument-access macros for !REPLACEMENT-check-in-arity--alt/n2/fR/retR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 2L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

    /* The 2th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG2  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN2 (JITTER_ARG2.fixnum)
#   define JITTER_ARGU2 (JITTER_ARG2.ufixnum)
#   define JITTER_ARGP2 (JITTER_ARG2.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 2L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

    /* The 2th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG2  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN2 (JITTER_ARG2.fixnum)
#   define JITTER_ARGU2 (JITTER_ARG2.ufixnum)
#   define JITTER_ARGP2 (JITTER_ARG2.pointer)
#   define JITTER_ARGF2 JITTER_ARGP2

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* When jumping to the non-relocatable part it is important not
   to use a fallback version of JITTER_COMPUTED_GOTO, in order to
   prevent GCC from tail-merging. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
    /* Jump to non-relocatable code. */
    JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);

    /* Here the residual arity is given as zero: it's too late to
       skip residuals, since we've already jumped and this code is
       unreachable.  The instruction pointer, if any, is advanced
       in the non-relocatable code. */
    JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-check-in-arity--alt/n2/fR/retR, _eREPLACEMENT_mcheck_min_marity_m_malt__n2__fR__retR, 0)

    /* Relocated code will jump to this label in non-relocated code. */
  JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
    JITTER_COMMENT_IN_ASM_("!REPLACEMENT-check-in-arity--alt/n2/fR/retR non-relocatable code");
#endif // #ifdef JITTER_REPLICATE
#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of !REPLACEMENT-check-in-arity--alt/n2/fR/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  no. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
//#if 0
  //fprintf (stderr, "Executing instruction %s..\n", "!REPLACEMENT-check-in-arity--alt/n2/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing replacement instruction %s..\n", "!REPLACEMENT-check-in-arity--alt/n2/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing non-relocatable instruction %s with JITTER_SPECIALIZED_INSTRUCTION_WORD_NO=%i..\n", "!REPLACEMENT-check-in-arity--alt/n2/fR/retR", (int) JITTER_SPECIALIZED_INSTRUCTION_WORD_NO); fflush (stderr);
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#undef JITTER_THIS_IS_A_REPLACEMENT
#define JITTER_THIS_IS_A_REPLACEMENT 1

    /* User code for !REPLACEMENT-check-in-arity--alt/n2/fR/retR . */
  {
/* User-specified code, user code block part: beginning. */

    // FIXME: this loops forever with no-threading (not with the other dispatches
    // including minimal threading) when the callee is compiled.  A Jitter bug.
    /* Here we can assume that the top object is a closure, without checking: we either
       already performed a type check, or the compiler decided it wasn't necessary. */
    jitterlisp_object top = JITTER_TOP_MAINSTACK();
    struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(top);

    /* FIXME: this is optimizable.  I should store the in-arity as a field, independently
       from the closure compiledness.  [Done] */
    if (JITTERLISP_IS_COMPILED_CLOSURE(top))
      {
        if (c->in_arity != JITTER_ARGN0)
          JITTER_BRANCH_FAST(JITTER_ARGF1);
      }
    else
      {
        /* The closure is interpreted.  Compute its in-arity.  We can assume that
           the formal list is well-formal, which is to say actually a proper list
           of distinct symbols. */
        struct jitterlisp_interpreted_closure *ic = & c->interpreted;
        jitterlisp_object rest = ic->formals;
        jitter_uint in_arity = 0;
        while (! JITTERLISP_IS_EMPTY_LIST(rest))
          {
            in_arity ++;
            rest = JITTERLISP_EXP_C_A_CDR(rest);
          }
        if (in_arity != JITTER_ARGN0)
          JITTER_BRANCH_FAST(JITTER_ARGF1);
      }
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for !REPLACEMENT-check-in-arity--alt/n2/fR/retR . */

  //fprintf (stderr, "..Executed replacement instruction %s\n", "!REPLACEMENT-check-in-arity--alt/n2/fR/retR");
  //fprintf (stderr, "..Executed instruction %s\n", "!REPLACEMENT-check-in-arity--alt/n2/fR/retR");
//#endif // #if 0
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
#ifdef JITTER_REPLICATE
  {
    /* Advance the instruction pointer, if any, to skip every
       residual but the last; branch back to replicated
       code. */
    const void *_jitter_back_to_replicated_code_pointer =
      JITTER_ARGP2;
    JITTER_SKIP_RESIDUALS_;
    goto * _jitter_back_to_replicated_code_pointer;
  }
#endif // #ifdef JITTER_REPLICATE

    /* Undefine the !REPLACEMENT-check-in-arity--alt/n2/fR/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1
#   undef JITTER_SLOW_REGISTER_OFFSET2
#   undef JITTER_ARG2
#   undef JITTER_ARGN2
#   undef JITTER_ARGU2
#   undef JITTER_ARGP2
#   undef JITTER_ARGF2

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#ifndef JITTER_REPLICATE
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-check-in-arity--alt/n2/fR/retR, _eREPLACEMENT_mcheck_min_marity_m_malt__n2__fR__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#endif // #ifndef JITTER_REPLICATE
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for !REPLACEMENT-check-in-arity--alt/n2/fR/retR, which started with its
       definitions. */
  }
#endif // #if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
/*  End of !REPLACEMENT-check-in-arity--alt/n2/fR/retR , a replacement specialised instruction */

  /* Ordinary specialised instruction !REPLACEMENT-check-in-arity--alt/n3/fR/retR (replacement) */
  /* Omit this specialised instruction altogether unless
     replacements are in fact supported in this
     configuration. */
#if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
  JITTER_INSTRUCTION_PROLOG_(!REPLACEMENT-check-in-arity--alt/n3/fR/retR, _eREPLACEMENT_mcheck_min_marity_m_malt__n3__fR__retR, cold)
  { /* This block begins with definitions for !REPLACEMENT-check-in-arity--alt/n3/fR/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       277
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         !REPLACEMENT-check-in-arity--alt/n3/fR/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "check-in-arity--alt"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "!REPLACEMENT-check-in-arity--alt/n3/fR/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _eREPLACEMENT_mcheck_min_marity_m_malt__n3__fR__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is non-relocatable.
       Its 2-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST JITTER_BRANCH
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
    /* This specialized instruction is non-relocatable.
       Its 2-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 2

  /* Define argument-access macros for !REPLACEMENT-check-in-arity--alt/n3/fR/retR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 3L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

    /* The 2th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG2  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN2 (JITTER_ARG2.fixnum)
#   define JITTER_ARGU2 (JITTER_ARG2.ufixnum)
#   define JITTER_ARGP2 (JITTER_ARG2.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 3L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

    /* The 2th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG2  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN2 (JITTER_ARG2.fixnum)
#   define JITTER_ARGU2 (JITTER_ARG2.ufixnum)
#   define JITTER_ARGP2 (JITTER_ARG2.pointer)
#   define JITTER_ARGF2 JITTER_ARGP2

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* When jumping to the non-relocatable part it is important not
   to use a fallback version of JITTER_COMPUTED_GOTO, in order to
   prevent GCC from tail-merging. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
    /* Jump to non-relocatable code. */
    JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);

    /* Here the residual arity is given as zero: it's too late to
       skip residuals, since we've already jumped and this code is
       unreachable.  The instruction pointer, if any, is advanced
       in the non-relocatable code. */
    JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-check-in-arity--alt/n3/fR/retR, _eREPLACEMENT_mcheck_min_marity_m_malt__n3__fR__retR, 0)

    /* Relocated code will jump to this label in non-relocated code. */
  JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
    JITTER_COMMENT_IN_ASM_("!REPLACEMENT-check-in-arity--alt/n3/fR/retR non-relocatable code");
#endif // #ifdef JITTER_REPLICATE
#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of !REPLACEMENT-check-in-arity--alt/n3/fR/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  no. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
//#if 0
  //fprintf (stderr, "Executing instruction %s..\n", "!REPLACEMENT-check-in-arity--alt/n3/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing replacement instruction %s..\n", "!REPLACEMENT-check-in-arity--alt/n3/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing non-relocatable instruction %s with JITTER_SPECIALIZED_INSTRUCTION_WORD_NO=%i..\n", "!REPLACEMENT-check-in-arity--alt/n3/fR/retR", (int) JITTER_SPECIALIZED_INSTRUCTION_WORD_NO); fflush (stderr);
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#undef JITTER_THIS_IS_A_REPLACEMENT
#define JITTER_THIS_IS_A_REPLACEMENT 1

    /* User code for !REPLACEMENT-check-in-arity--alt/n3/fR/retR . */
  {
/* User-specified code, user code block part: beginning. */

    // FIXME: this loops forever with no-threading (not with the other dispatches
    // including minimal threading) when the callee is compiled.  A Jitter bug.
    /* Here we can assume that the top object is a closure, without checking: we either
       already performed a type check, or the compiler decided it wasn't necessary. */
    jitterlisp_object top = JITTER_TOP_MAINSTACK();
    struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(top);

    /* FIXME: this is optimizable.  I should store the in-arity as a field, independently
       from the closure compiledness.  [Done] */
    if (JITTERLISP_IS_COMPILED_CLOSURE(top))
      {
        if (c->in_arity != JITTER_ARGN0)
          JITTER_BRANCH_FAST(JITTER_ARGF1);
      }
    else
      {
        /* The closure is interpreted.  Compute its in-arity.  We can assume that
           the formal list is well-formal, which is to say actually a proper list
           of distinct symbols. */
        struct jitterlisp_interpreted_closure *ic = & c->interpreted;
        jitterlisp_object rest = ic->formals;
        jitter_uint in_arity = 0;
        while (! JITTERLISP_IS_EMPTY_LIST(rest))
          {
            in_arity ++;
            rest = JITTERLISP_EXP_C_A_CDR(rest);
          }
        if (in_arity != JITTER_ARGN0)
          JITTER_BRANCH_FAST(JITTER_ARGF1);
      }
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for !REPLACEMENT-check-in-arity--alt/n3/fR/retR . */

  //fprintf (stderr, "..Executed replacement instruction %s\n", "!REPLACEMENT-check-in-arity--alt/n3/fR/retR");
  //fprintf (stderr, "..Executed instruction %s\n", "!REPLACEMENT-check-in-arity--alt/n3/fR/retR");
//#endif // #if 0
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
#ifdef JITTER_REPLICATE
  {
    /* Advance the instruction pointer, if any, to skip every
       residual but the last; branch back to replicated
       code. */
    const void *_jitter_back_to_replicated_code_pointer =
      JITTER_ARGP2;
    JITTER_SKIP_RESIDUALS_;
    goto * _jitter_back_to_replicated_code_pointer;
  }
#endif // #ifdef JITTER_REPLICATE

    /* Undefine the !REPLACEMENT-check-in-arity--alt/n3/fR/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1
#   undef JITTER_SLOW_REGISTER_OFFSET2
#   undef JITTER_ARG2
#   undef JITTER_ARGN2
#   undef JITTER_ARGU2
#   undef JITTER_ARGP2
#   undef JITTER_ARGF2

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#ifndef JITTER_REPLICATE
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-check-in-arity--alt/n3/fR/retR, _eREPLACEMENT_mcheck_min_marity_m_malt__n3__fR__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#endif // #ifndef JITTER_REPLICATE
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for !REPLACEMENT-check-in-arity--alt/n3/fR/retR, which started with its
       definitions. */
  }
#endif // #if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
/*  End of !REPLACEMENT-check-in-arity--alt/n3/fR/retR , a replacement specialised instruction */

  /* Ordinary specialised instruction !REPLACEMENT-check-in-arity--alt/n4/fR/retR (replacement) */
  /* Omit this specialised instruction altogether unless
     replacements are in fact supported in this
     configuration. */
#if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
  JITTER_INSTRUCTION_PROLOG_(!REPLACEMENT-check-in-arity--alt/n4/fR/retR, _eREPLACEMENT_mcheck_min_marity_m_malt__n4__fR__retR, cold)
  { /* This block begins with definitions for !REPLACEMENT-check-in-arity--alt/n4/fR/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       278
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         !REPLACEMENT-check-in-arity--alt/n4/fR/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "check-in-arity--alt"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "!REPLACEMENT-check-in-arity--alt/n4/fR/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _eREPLACEMENT_mcheck_min_marity_m_malt__n4__fR__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is non-relocatable.
       Its 2-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST JITTER_BRANCH
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
    /* This specialized instruction is non-relocatable.
       Its 2-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 2

  /* Define argument-access macros for !REPLACEMENT-check-in-arity--alt/n4/fR/retR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 4L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

    /* The 2th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG2  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN2 (JITTER_ARG2.fixnum)
#   define JITTER_ARGU2 (JITTER_ARG2.ufixnum)
#   define JITTER_ARGP2 (JITTER_ARG2.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 4L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

    /* The 2th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG2  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN2 (JITTER_ARG2.fixnum)
#   define JITTER_ARGU2 (JITTER_ARG2.ufixnum)
#   define JITTER_ARGP2 (JITTER_ARG2.pointer)
#   define JITTER_ARGF2 JITTER_ARGP2

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* When jumping to the non-relocatable part it is important not
   to use a fallback version of JITTER_COMPUTED_GOTO, in order to
   prevent GCC from tail-merging. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
    /* Jump to non-relocatable code. */
    JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);

    /* Here the residual arity is given as zero: it's too late to
       skip residuals, since we've already jumped and this code is
       unreachable.  The instruction pointer, if any, is advanced
       in the non-relocatable code. */
    JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-check-in-arity--alt/n4/fR/retR, _eREPLACEMENT_mcheck_min_marity_m_malt__n4__fR__retR, 0)

    /* Relocated code will jump to this label in non-relocated code. */
  JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
    JITTER_COMMENT_IN_ASM_("!REPLACEMENT-check-in-arity--alt/n4/fR/retR non-relocatable code");
#endif // #ifdef JITTER_REPLICATE
#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of !REPLACEMENT-check-in-arity--alt/n4/fR/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  no. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
//#if 0
  //fprintf (stderr, "Executing instruction %s..\n", "!REPLACEMENT-check-in-arity--alt/n4/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing replacement instruction %s..\n", "!REPLACEMENT-check-in-arity--alt/n4/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing non-relocatable instruction %s with JITTER_SPECIALIZED_INSTRUCTION_WORD_NO=%i..\n", "!REPLACEMENT-check-in-arity--alt/n4/fR/retR", (int) JITTER_SPECIALIZED_INSTRUCTION_WORD_NO); fflush (stderr);
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#undef JITTER_THIS_IS_A_REPLACEMENT
#define JITTER_THIS_IS_A_REPLACEMENT 1

    /* User code for !REPLACEMENT-check-in-arity--alt/n4/fR/retR . */
  {
/* User-specified code, user code block part: beginning. */

    // FIXME: this loops forever with no-threading (not with the other dispatches
    // including minimal threading) when the callee is compiled.  A Jitter bug.
    /* Here we can assume that the top object is a closure, without checking: we either
       already performed a type check, or the compiler decided it wasn't necessary. */
    jitterlisp_object top = JITTER_TOP_MAINSTACK();
    struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(top);

    /* FIXME: this is optimizable.  I should store the in-arity as a field, independently
       from the closure compiledness.  [Done] */
    if (JITTERLISP_IS_COMPILED_CLOSURE(top))
      {
        if (c->in_arity != JITTER_ARGN0)
          JITTER_BRANCH_FAST(JITTER_ARGF1);
      }
    else
      {
        /* The closure is interpreted.  Compute its in-arity.  We can assume that
           the formal list is well-formal, which is to say actually a proper list
           of distinct symbols. */
        struct jitterlisp_interpreted_closure *ic = & c->interpreted;
        jitterlisp_object rest = ic->formals;
        jitter_uint in_arity = 0;
        while (! JITTERLISP_IS_EMPTY_LIST(rest))
          {
            in_arity ++;
            rest = JITTERLISP_EXP_C_A_CDR(rest);
          }
        if (in_arity != JITTER_ARGN0)
          JITTER_BRANCH_FAST(JITTER_ARGF1);
      }
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for !REPLACEMENT-check-in-arity--alt/n4/fR/retR . */

  //fprintf (stderr, "..Executed replacement instruction %s\n", "!REPLACEMENT-check-in-arity--alt/n4/fR/retR");
  //fprintf (stderr, "..Executed instruction %s\n", "!REPLACEMENT-check-in-arity--alt/n4/fR/retR");
//#endif // #if 0
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
#ifdef JITTER_REPLICATE
  {
    /* Advance the instruction pointer, if any, to skip every
       residual but the last; branch back to replicated
       code. */
    const void *_jitter_back_to_replicated_code_pointer =
      JITTER_ARGP2;
    JITTER_SKIP_RESIDUALS_;
    goto * _jitter_back_to_replicated_code_pointer;
  }
#endif // #ifdef JITTER_REPLICATE

    /* Undefine the !REPLACEMENT-check-in-arity--alt/n4/fR/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1
#   undef JITTER_SLOW_REGISTER_OFFSET2
#   undef JITTER_ARG2
#   undef JITTER_ARGN2
#   undef JITTER_ARGU2
#   undef JITTER_ARGP2
#   undef JITTER_ARGF2

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#ifndef JITTER_REPLICATE
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-check-in-arity--alt/n4/fR/retR, _eREPLACEMENT_mcheck_min_marity_m_malt__n4__fR__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#endif // #ifndef JITTER_REPLICATE
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for !REPLACEMENT-check-in-arity--alt/n4/fR/retR, which started with its
       definitions. */
  }
#endif // #if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
/*  End of !REPLACEMENT-check-in-arity--alt/n4/fR/retR , a replacement specialised instruction */

  /* Ordinary specialised instruction !REPLACEMENT-check-in-arity--alt/n5/fR/retR (replacement) */
  /* Omit this specialised instruction altogether unless
     replacements are in fact supported in this
     configuration. */
#if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
  JITTER_INSTRUCTION_PROLOG_(!REPLACEMENT-check-in-arity--alt/n5/fR/retR, _eREPLACEMENT_mcheck_min_marity_m_malt__n5__fR__retR, cold)
  { /* This block begins with definitions for !REPLACEMENT-check-in-arity--alt/n5/fR/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       279
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         !REPLACEMENT-check-in-arity--alt/n5/fR/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "check-in-arity--alt"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "!REPLACEMENT-check-in-arity--alt/n5/fR/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _eREPLACEMENT_mcheck_min_marity_m_malt__n5__fR__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is non-relocatable.
       Its 2-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST JITTER_BRANCH
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
    /* This specialized instruction is non-relocatable.
       Its 2-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 2

  /* Define argument-access macros for !REPLACEMENT-check-in-arity--alt/n5/fR/retR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 5L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

    /* The 2th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG2  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN2 (JITTER_ARG2.fixnum)
#   define JITTER_ARGU2 (JITTER_ARG2.ufixnum)
#   define JITTER_ARGP2 (JITTER_ARG2.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 5L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

    /* The 2th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG2  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN2 (JITTER_ARG2.fixnum)
#   define JITTER_ARGU2 (JITTER_ARG2.ufixnum)
#   define JITTER_ARGP2 (JITTER_ARG2.pointer)
#   define JITTER_ARGF2 JITTER_ARGP2

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* When jumping to the non-relocatable part it is important not
   to use a fallback version of JITTER_COMPUTED_GOTO, in order to
   prevent GCC from tail-merging. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
    /* Jump to non-relocatable code. */
    JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);

    /* Here the residual arity is given as zero: it's too late to
       skip residuals, since we've already jumped and this code is
       unreachable.  The instruction pointer, if any, is advanced
       in the non-relocatable code. */
    JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-check-in-arity--alt/n5/fR/retR, _eREPLACEMENT_mcheck_min_marity_m_malt__n5__fR__retR, 0)

    /* Relocated code will jump to this label in non-relocated code. */
  JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
    JITTER_COMMENT_IN_ASM_("!REPLACEMENT-check-in-arity--alt/n5/fR/retR non-relocatable code");
#endif // #ifdef JITTER_REPLICATE
#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of !REPLACEMENT-check-in-arity--alt/n5/fR/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  no. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
//#if 0
  //fprintf (stderr, "Executing instruction %s..\n", "!REPLACEMENT-check-in-arity--alt/n5/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing replacement instruction %s..\n", "!REPLACEMENT-check-in-arity--alt/n5/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing non-relocatable instruction %s with JITTER_SPECIALIZED_INSTRUCTION_WORD_NO=%i..\n", "!REPLACEMENT-check-in-arity--alt/n5/fR/retR", (int) JITTER_SPECIALIZED_INSTRUCTION_WORD_NO); fflush (stderr);
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#undef JITTER_THIS_IS_A_REPLACEMENT
#define JITTER_THIS_IS_A_REPLACEMENT 1

    /* User code for !REPLACEMENT-check-in-arity--alt/n5/fR/retR . */
  {
/* User-specified code, user code block part: beginning. */

    // FIXME: this loops forever with no-threading (not with the other dispatches
    // including minimal threading) when the callee is compiled.  A Jitter bug.
    /* Here we can assume that the top object is a closure, without checking: we either
       already performed a type check, or the compiler decided it wasn't necessary. */
    jitterlisp_object top = JITTER_TOP_MAINSTACK();
    struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(top);

    /* FIXME: this is optimizable.  I should store the in-arity as a field, independently
       from the closure compiledness.  [Done] */
    if (JITTERLISP_IS_COMPILED_CLOSURE(top))
      {
        if (c->in_arity != JITTER_ARGN0)
          JITTER_BRANCH_FAST(JITTER_ARGF1);
      }
    else
      {
        /* The closure is interpreted.  Compute its in-arity.  We can assume that
           the formal list is well-formal, which is to say actually a proper list
           of distinct symbols. */
        struct jitterlisp_interpreted_closure *ic = & c->interpreted;
        jitterlisp_object rest = ic->formals;
        jitter_uint in_arity = 0;
        while (! JITTERLISP_IS_EMPTY_LIST(rest))
          {
            in_arity ++;
            rest = JITTERLISP_EXP_C_A_CDR(rest);
          }
        if (in_arity != JITTER_ARGN0)
          JITTER_BRANCH_FAST(JITTER_ARGF1);
      }
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for !REPLACEMENT-check-in-arity--alt/n5/fR/retR . */

  //fprintf (stderr, "..Executed replacement instruction %s\n", "!REPLACEMENT-check-in-arity--alt/n5/fR/retR");
  //fprintf (stderr, "..Executed instruction %s\n", "!REPLACEMENT-check-in-arity--alt/n5/fR/retR");
//#endif // #if 0
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
#ifdef JITTER_REPLICATE
  {
    /* Advance the instruction pointer, if any, to skip every
       residual but the last; branch back to replicated
       code. */
    const void *_jitter_back_to_replicated_code_pointer =
      JITTER_ARGP2;
    JITTER_SKIP_RESIDUALS_;
    goto * _jitter_back_to_replicated_code_pointer;
  }
#endif // #ifdef JITTER_REPLICATE

    /* Undefine the !REPLACEMENT-check-in-arity--alt/n5/fR/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1
#   undef JITTER_SLOW_REGISTER_OFFSET2
#   undef JITTER_ARG2
#   undef JITTER_ARGN2
#   undef JITTER_ARGU2
#   undef JITTER_ARGP2
#   undef JITTER_ARGF2

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#ifndef JITTER_REPLICATE
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-check-in-arity--alt/n5/fR/retR, _eREPLACEMENT_mcheck_min_marity_m_malt__n5__fR__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#endif // #ifndef JITTER_REPLICATE
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for !REPLACEMENT-check-in-arity--alt/n5/fR/retR, which started with its
       definitions. */
  }
#endif // #if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
/*  End of !REPLACEMENT-check-in-arity--alt/n5/fR/retR , a replacement specialised instruction */

  /* Ordinary specialised instruction !REPLACEMENT-check-in-arity--alt/n6/fR/retR (replacement) */
  /* Omit this specialised instruction altogether unless
     replacements are in fact supported in this
     configuration. */
#if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
  JITTER_INSTRUCTION_PROLOG_(!REPLACEMENT-check-in-arity--alt/n6/fR/retR, _eREPLACEMENT_mcheck_min_marity_m_malt__n6__fR__retR, cold)
  { /* This block begins with definitions for !REPLACEMENT-check-in-arity--alt/n6/fR/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       280
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         !REPLACEMENT-check-in-arity--alt/n6/fR/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "check-in-arity--alt"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "!REPLACEMENT-check-in-arity--alt/n6/fR/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _eREPLACEMENT_mcheck_min_marity_m_malt__n6__fR__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is non-relocatable.
       Its 2-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST JITTER_BRANCH
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
    /* This specialized instruction is non-relocatable.
       Its 2-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 2

  /* Define argument-access macros for !REPLACEMENT-check-in-arity--alt/n6/fR/retR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 6L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

    /* The 2th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG2  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN2 (JITTER_ARG2.fixnum)
#   define JITTER_ARGU2 (JITTER_ARG2.ufixnum)
#   define JITTER_ARGP2 (JITTER_ARG2.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 6L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

    /* The 2th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG2  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN2 (JITTER_ARG2.fixnum)
#   define JITTER_ARGU2 (JITTER_ARG2.ufixnum)
#   define JITTER_ARGP2 (JITTER_ARG2.pointer)
#   define JITTER_ARGF2 JITTER_ARGP2

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* When jumping to the non-relocatable part it is important not
   to use a fallback version of JITTER_COMPUTED_GOTO, in order to
   prevent GCC from tail-merging. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
    /* Jump to non-relocatable code. */
    JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);

    /* Here the residual arity is given as zero: it's too late to
       skip residuals, since we've already jumped and this code is
       unreachable.  The instruction pointer, if any, is advanced
       in the non-relocatable code. */
    JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-check-in-arity--alt/n6/fR/retR, _eREPLACEMENT_mcheck_min_marity_m_malt__n6__fR__retR, 0)

    /* Relocated code will jump to this label in non-relocated code. */
  JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
    JITTER_COMMENT_IN_ASM_("!REPLACEMENT-check-in-arity--alt/n6/fR/retR non-relocatable code");
#endif // #ifdef JITTER_REPLICATE
#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of !REPLACEMENT-check-in-arity--alt/n6/fR/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  no. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
//#if 0
  //fprintf (stderr, "Executing instruction %s..\n", "!REPLACEMENT-check-in-arity--alt/n6/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing replacement instruction %s..\n", "!REPLACEMENT-check-in-arity--alt/n6/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing non-relocatable instruction %s with JITTER_SPECIALIZED_INSTRUCTION_WORD_NO=%i..\n", "!REPLACEMENT-check-in-arity--alt/n6/fR/retR", (int) JITTER_SPECIALIZED_INSTRUCTION_WORD_NO); fflush (stderr);
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#undef JITTER_THIS_IS_A_REPLACEMENT
#define JITTER_THIS_IS_A_REPLACEMENT 1

    /* User code for !REPLACEMENT-check-in-arity--alt/n6/fR/retR . */
  {
/* User-specified code, user code block part: beginning. */

    // FIXME: this loops forever with no-threading (not with the other dispatches
    // including minimal threading) when the callee is compiled.  A Jitter bug.
    /* Here we can assume that the top object is a closure, without checking: we either
       already performed a type check, or the compiler decided it wasn't necessary. */
    jitterlisp_object top = JITTER_TOP_MAINSTACK();
    struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(top);

    /* FIXME: this is optimizable.  I should store the in-arity as a field, independently
       from the closure compiledness.  [Done] */
    if (JITTERLISP_IS_COMPILED_CLOSURE(top))
      {
        if (c->in_arity != JITTER_ARGN0)
          JITTER_BRANCH_FAST(JITTER_ARGF1);
      }
    else
      {
        /* The closure is interpreted.  Compute its in-arity.  We can assume that
           the formal list is well-formal, which is to say actually a proper list
           of distinct symbols. */
        struct jitterlisp_interpreted_closure *ic = & c->interpreted;
        jitterlisp_object rest = ic->formals;
        jitter_uint in_arity = 0;
        while (! JITTERLISP_IS_EMPTY_LIST(rest))
          {
            in_arity ++;
            rest = JITTERLISP_EXP_C_A_CDR(rest);
          }
        if (in_arity != JITTER_ARGN0)
          JITTER_BRANCH_FAST(JITTER_ARGF1);
      }
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for !REPLACEMENT-check-in-arity--alt/n6/fR/retR . */

  //fprintf (stderr, "..Executed replacement instruction %s\n", "!REPLACEMENT-check-in-arity--alt/n6/fR/retR");
  //fprintf (stderr, "..Executed instruction %s\n", "!REPLACEMENT-check-in-arity--alt/n6/fR/retR");
//#endif // #if 0
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
#ifdef JITTER_REPLICATE
  {
    /* Advance the instruction pointer, if any, to skip every
       residual but the last; branch back to replicated
       code. */
    const void *_jitter_back_to_replicated_code_pointer =
      JITTER_ARGP2;
    JITTER_SKIP_RESIDUALS_;
    goto * _jitter_back_to_replicated_code_pointer;
  }
#endif // #ifdef JITTER_REPLICATE

    /* Undefine the !REPLACEMENT-check-in-arity--alt/n6/fR/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1
#   undef JITTER_SLOW_REGISTER_OFFSET2
#   undef JITTER_ARG2
#   undef JITTER_ARGN2
#   undef JITTER_ARGU2
#   undef JITTER_ARGP2
#   undef JITTER_ARGF2

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#ifndef JITTER_REPLICATE
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-check-in-arity--alt/n6/fR/retR, _eREPLACEMENT_mcheck_min_marity_m_malt__n6__fR__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#endif // #ifndef JITTER_REPLICATE
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for !REPLACEMENT-check-in-arity--alt/n6/fR/retR, which started with its
       definitions. */
  }
#endif // #if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
/*  End of !REPLACEMENT-check-in-arity--alt/n6/fR/retR , a replacement specialised instruction */

  /* Ordinary specialised instruction !REPLACEMENT-check-in-arity--alt/n7/fR/retR (replacement) */
  /* Omit this specialised instruction altogether unless
     replacements are in fact supported in this
     configuration. */
#if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
  JITTER_INSTRUCTION_PROLOG_(!REPLACEMENT-check-in-arity--alt/n7/fR/retR, _eREPLACEMENT_mcheck_min_marity_m_malt__n7__fR__retR, cold)
  { /* This block begins with definitions for !REPLACEMENT-check-in-arity--alt/n7/fR/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       281
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         !REPLACEMENT-check-in-arity--alt/n7/fR/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "check-in-arity--alt"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "!REPLACEMENT-check-in-arity--alt/n7/fR/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _eREPLACEMENT_mcheck_min_marity_m_malt__n7__fR__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is non-relocatable.
       Its 2-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST JITTER_BRANCH
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
    /* This specialized instruction is non-relocatable.
       Its 2-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 2

  /* Define argument-access macros for !REPLACEMENT-check-in-arity--alt/n7/fR/retR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 7L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

    /* The 2th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG2  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN2 (JITTER_ARG2.fixnum)
#   define JITTER_ARGU2 (JITTER_ARG2.ufixnum)
#   define JITTER_ARGP2 (JITTER_ARG2.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 7L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

    /* The 2th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG2  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN2 (JITTER_ARG2.fixnum)
#   define JITTER_ARGU2 (JITTER_ARG2.ufixnum)
#   define JITTER_ARGP2 (JITTER_ARG2.pointer)
#   define JITTER_ARGF2 JITTER_ARGP2

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* When jumping to the non-relocatable part it is important not
   to use a fallback version of JITTER_COMPUTED_GOTO, in order to
   prevent GCC from tail-merging. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
    /* Jump to non-relocatable code. */
    JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);

    /* Here the residual arity is given as zero: it's too late to
       skip residuals, since we've already jumped and this code is
       unreachable.  The instruction pointer, if any, is advanced
       in the non-relocatable code. */
    JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-check-in-arity--alt/n7/fR/retR, _eREPLACEMENT_mcheck_min_marity_m_malt__n7__fR__retR, 0)

    /* Relocated code will jump to this label in non-relocated code. */
  JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
    JITTER_COMMENT_IN_ASM_("!REPLACEMENT-check-in-arity--alt/n7/fR/retR non-relocatable code");
#endif // #ifdef JITTER_REPLICATE
#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of !REPLACEMENT-check-in-arity--alt/n7/fR/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  no. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
//#if 0
  //fprintf (stderr, "Executing instruction %s..\n", "!REPLACEMENT-check-in-arity--alt/n7/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing replacement instruction %s..\n", "!REPLACEMENT-check-in-arity--alt/n7/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing non-relocatable instruction %s with JITTER_SPECIALIZED_INSTRUCTION_WORD_NO=%i..\n", "!REPLACEMENT-check-in-arity--alt/n7/fR/retR", (int) JITTER_SPECIALIZED_INSTRUCTION_WORD_NO); fflush (stderr);
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#undef JITTER_THIS_IS_A_REPLACEMENT
#define JITTER_THIS_IS_A_REPLACEMENT 1

    /* User code for !REPLACEMENT-check-in-arity--alt/n7/fR/retR . */
  {
/* User-specified code, user code block part: beginning. */

    // FIXME: this loops forever with no-threading (not with the other dispatches
    // including minimal threading) when the callee is compiled.  A Jitter bug.
    /* Here we can assume that the top object is a closure, without checking: we either
       already performed a type check, or the compiler decided it wasn't necessary. */
    jitterlisp_object top = JITTER_TOP_MAINSTACK();
    struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(top);

    /* FIXME: this is optimizable.  I should store the in-arity as a field, independently
       from the closure compiledness.  [Done] */
    if (JITTERLISP_IS_COMPILED_CLOSURE(top))
      {
        if (c->in_arity != JITTER_ARGN0)
          JITTER_BRANCH_FAST(JITTER_ARGF1);
      }
    else
      {
        /* The closure is interpreted.  Compute its in-arity.  We can assume that
           the formal list is well-formal, which is to say actually a proper list
           of distinct symbols. */
        struct jitterlisp_interpreted_closure *ic = & c->interpreted;
        jitterlisp_object rest = ic->formals;
        jitter_uint in_arity = 0;
        while (! JITTERLISP_IS_EMPTY_LIST(rest))
          {
            in_arity ++;
            rest = JITTERLISP_EXP_C_A_CDR(rest);
          }
        if (in_arity != JITTER_ARGN0)
          JITTER_BRANCH_FAST(JITTER_ARGF1);
      }
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for !REPLACEMENT-check-in-arity--alt/n7/fR/retR . */

  //fprintf (stderr, "..Executed replacement instruction %s\n", "!REPLACEMENT-check-in-arity--alt/n7/fR/retR");
  //fprintf (stderr, "..Executed instruction %s\n", "!REPLACEMENT-check-in-arity--alt/n7/fR/retR");
//#endif // #if 0
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
#ifdef JITTER_REPLICATE
  {
    /* Advance the instruction pointer, if any, to skip every
       residual but the last; branch back to replicated
       code. */
    const void *_jitter_back_to_replicated_code_pointer =
      JITTER_ARGP2;
    JITTER_SKIP_RESIDUALS_;
    goto * _jitter_back_to_replicated_code_pointer;
  }
#endif // #ifdef JITTER_REPLICATE

    /* Undefine the !REPLACEMENT-check-in-arity--alt/n7/fR/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1
#   undef JITTER_SLOW_REGISTER_OFFSET2
#   undef JITTER_ARG2
#   undef JITTER_ARGN2
#   undef JITTER_ARGU2
#   undef JITTER_ARGP2
#   undef JITTER_ARGF2

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#ifndef JITTER_REPLICATE
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-check-in-arity--alt/n7/fR/retR, _eREPLACEMENT_mcheck_min_marity_m_malt__n7__fR__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#endif // #ifndef JITTER_REPLICATE
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for !REPLACEMENT-check-in-arity--alt/n7/fR/retR, which started with its
       definitions. */
  }
#endif // #if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
/*  End of !REPLACEMENT-check-in-arity--alt/n7/fR/retR , a replacement specialised instruction */

  /* Ordinary specialised instruction !REPLACEMENT-check-in-arity--alt/n8/fR/retR (replacement) */
  /* Omit this specialised instruction altogether unless
     replacements are in fact supported in this
     configuration. */
#if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
  JITTER_INSTRUCTION_PROLOG_(!REPLACEMENT-check-in-arity--alt/n8/fR/retR, _eREPLACEMENT_mcheck_min_marity_m_malt__n8__fR__retR, cold)
  { /* This block begins with definitions for !REPLACEMENT-check-in-arity--alt/n8/fR/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       282
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         !REPLACEMENT-check-in-arity--alt/n8/fR/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "check-in-arity--alt"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "!REPLACEMENT-check-in-arity--alt/n8/fR/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _eREPLACEMENT_mcheck_min_marity_m_malt__n8__fR__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is non-relocatable.
       Its 2-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST JITTER_BRANCH
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
    /* This specialized instruction is non-relocatable.
       Its 2-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 2

  /* Define argument-access macros for !REPLACEMENT-check-in-arity--alt/n8/fR/retR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 8L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

    /* The 2th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG2  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN2 (JITTER_ARG2.fixnum)
#   define JITTER_ARGU2 (JITTER_ARG2.ufixnum)
#   define JITTER_ARGP2 (JITTER_ARG2.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 8L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

    /* The 2th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG2  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN2 (JITTER_ARG2.fixnum)
#   define JITTER_ARGU2 (JITTER_ARG2.ufixnum)
#   define JITTER_ARGP2 (JITTER_ARG2.pointer)
#   define JITTER_ARGF2 JITTER_ARGP2

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* When jumping to the non-relocatable part it is important not
   to use a fallback version of JITTER_COMPUTED_GOTO, in order to
   prevent GCC from tail-merging. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
    /* Jump to non-relocatable code. */
    JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);

    /* Here the residual arity is given as zero: it's too late to
       skip residuals, since we've already jumped and this code is
       unreachable.  The instruction pointer, if any, is advanced
       in the non-relocatable code. */
    JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-check-in-arity--alt/n8/fR/retR, _eREPLACEMENT_mcheck_min_marity_m_malt__n8__fR__retR, 0)

    /* Relocated code will jump to this label in non-relocated code. */
  JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
    JITTER_COMMENT_IN_ASM_("!REPLACEMENT-check-in-arity--alt/n8/fR/retR non-relocatable code");
#endif // #ifdef JITTER_REPLICATE
#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of !REPLACEMENT-check-in-arity--alt/n8/fR/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  no. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
//#if 0
  //fprintf (stderr, "Executing instruction %s..\n", "!REPLACEMENT-check-in-arity--alt/n8/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing replacement instruction %s..\n", "!REPLACEMENT-check-in-arity--alt/n8/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing non-relocatable instruction %s with JITTER_SPECIALIZED_INSTRUCTION_WORD_NO=%i..\n", "!REPLACEMENT-check-in-arity--alt/n8/fR/retR", (int) JITTER_SPECIALIZED_INSTRUCTION_WORD_NO); fflush (stderr);
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#undef JITTER_THIS_IS_A_REPLACEMENT
#define JITTER_THIS_IS_A_REPLACEMENT 1

    /* User code for !REPLACEMENT-check-in-arity--alt/n8/fR/retR . */
  {
/* User-specified code, user code block part: beginning. */

    // FIXME: this loops forever with no-threading (not with the other dispatches
    // including minimal threading) when the callee is compiled.  A Jitter bug.
    /* Here we can assume that the top object is a closure, without checking: we either
       already performed a type check, or the compiler decided it wasn't necessary. */
    jitterlisp_object top = JITTER_TOP_MAINSTACK();
    struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(top);

    /* FIXME: this is optimizable.  I should store the in-arity as a field, independently
       from the closure compiledness.  [Done] */
    if (JITTERLISP_IS_COMPILED_CLOSURE(top))
      {
        if (c->in_arity != JITTER_ARGN0)
          JITTER_BRANCH_FAST(JITTER_ARGF1);
      }
    else
      {
        /* The closure is interpreted.  Compute its in-arity.  We can assume that
           the formal list is well-formal, which is to say actually a proper list
           of distinct symbols. */
        struct jitterlisp_interpreted_closure *ic = & c->interpreted;
        jitterlisp_object rest = ic->formals;
        jitter_uint in_arity = 0;
        while (! JITTERLISP_IS_EMPTY_LIST(rest))
          {
            in_arity ++;
            rest = JITTERLISP_EXP_C_A_CDR(rest);
          }
        if (in_arity != JITTER_ARGN0)
          JITTER_BRANCH_FAST(JITTER_ARGF1);
      }
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for !REPLACEMENT-check-in-arity--alt/n8/fR/retR . */

  //fprintf (stderr, "..Executed replacement instruction %s\n", "!REPLACEMENT-check-in-arity--alt/n8/fR/retR");
  //fprintf (stderr, "..Executed instruction %s\n", "!REPLACEMENT-check-in-arity--alt/n8/fR/retR");
//#endif // #if 0
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
#ifdef JITTER_REPLICATE
  {
    /* Advance the instruction pointer, if any, to skip every
       residual but the last; branch back to replicated
       code. */
    const void *_jitter_back_to_replicated_code_pointer =
      JITTER_ARGP2;
    JITTER_SKIP_RESIDUALS_;
    goto * _jitter_back_to_replicated_code_pointer;
  }
#endif // #ifdef JITTER_REPLICATE

    /* Undefine the !REPLACEMENT-check-in-arity--alt/n8/fR/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1
#   undef JITTER_SLOW_REGISTER_OFFSET2
#   undef JITTER_ARG2
#   undef JITTER_ARGN2
#   undef JITTER_ARGU2
#   undef JITTER_ARGP2
#   undef JITTER_ARGF2

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#ifndef JITTER_REPLICATE
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-check-in-arity--alt/n8/fR/retR, _eREPLACEMENT_mcheck_min_marity_m_malt__n8__fR__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#endif // #ifndef JITTER_REPLICATE
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for !REPLACEMENT-check-in-arity--alt/n8/fR/retR, which started with its
       definitions. */
  }
#endif // #if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
/*  End of !REPLACEMENT-check-in-arity--alt/n8/fR/retR , a replacement specialised instruction */

  /* Ordinary specialised instruction !REPLACEMENT-check-in-arity--alt/n9/fR/retR (replacement) */
  /* Omit this specialised instruction altogether unless
     replacements are in fact supported in this
     configuration. */
#if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
  JITTER_INSTRUCTION_PROLOG_(!REPLACEMENT-check-in-arity--alt/n9/fR/retR, _eREPLACEMENT_mcheck_min_marity_m_malt__n9__fR__retR, cold)
  { /* This block begins with definitions for !REPLACEMENT-check-in-arity--alt/n9/fR/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       283
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         !REPLACEMENT-check-in-arity--alt/n9/fR/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "check-in-arity--alt"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "!REPLACEMENT-check-in-arity--alt/n9/fR/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _eREPLACEMENT_mcheck_min_marity_m_malt__n9__fR__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is non-relocatable.
       Its 2-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST JITTER_BRANCH
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
    /* This specialized instruction is non-relocatable.
       Its 2-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 2

  /* Define argument-access macros for !REPLACEMENT-check-in-arity--alt/n9/fR/retR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 9L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

    /* The 2th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG2  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN2 (JITTER_ARG2.fixnum)
#   define JITTER_ARGU2 (JITTER_ARG2.ufixnum)
#   define JITTER_ARGP2 (JITTER_ARG2.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 9L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

    /* The 2th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG2  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN2 (JITTER_ARG2.fixnum)
#   define JITTER_ARGU2 (JITTER_ARG2.ufixnum)
#   define JITTER_ARGP2 (JITTER_ARG2.pointer)
#   define JITTER_ARGF2 JITTER_ARGP2

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* When jumping to the non-relocatable part it is important not
   to use a fallback version of JITTER_COMPUTED_GOTO, in order to
   prevent GCC from tail-merging. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
    /* Jump to non-relocatable code. */
    JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);

    /* Here the residual arity is given as zero: it's too late to
       skip residuals, since we've already jumped and this code is
       unreachable.  The instruction pointer, if any, is advanced
       in the non-relocatable code. */
    JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-check-in-arity--alt/n9/fR/retR, _eREPLACEMENT_mcheck_min_marity_m_malt__n9__fR__retR, 0)

    /* Relocated code will jump to this label in non-relocated code. */
  JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
    JITTER_COMMENT_IN_ASM_("!REPLACEMENT-check-in-arity--alt/n9/fR/retR non-relocatable code");
#endif // #ifdef JITTER_REPLICATE
#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of !REPLACEMENT-check-in-arity--alt/n9/fR/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  no. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
//#if 0
  //fprintf (stderr, "Executing instruction %s..\n", "!REPLACEMENT-check-in-arity--alt/n9/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing replacement instruction %s..\n", "!REPLACEMENT-check-in-arity--alt/n9/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing non-relocatable instruction %s with JITTER_SPECIALIZED_INSTRUCTION_WORD_NO=%i..\n", "!REPLACEMENT-check-in-arity--alt/n9/fR/retR", (int) JITTER_SPECIALIZED_INSTRUCTION_WORD_NO); fflush (stderr);
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#undef JITTER_THIS_IS_A_REPLACEMENT
#define JITTER_THIS_IS_A_REPLACEMENT 1

    /* User code for !REPLACEMENT-check-in-arity--alt/n9/fR/retR . */
  {
/* User-specified code, user code block part: beginning. */

    // FIXME: this loops forever with no-threading (not with the other dispatches
    // including minimal threading) when the callee is compiled.  A Jitter bug.
    /* Here we can assume that the top object is a closure, without checking: we either
       already performed a type check, or the compiler decided it wasn't necessary. */
    jitterlisp_object top = JITTER_TOP_MAINSTACK();
    struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(top);

    /* FIXME: this is optimizable.  I should store the in-arity as a field, independently
       from the closure compiledness.  [Done] */
    if (JITTERLISP_IS_COMPILED_CLOSURE(top))
      {
        if (c->in_arity != JITTER_ARGN0)
          JITTER_BRANCH_FAST(JITTER_ARGF1);
      }
    else
      {
        /* The closure is interpreted.  Compute its in-arity.  We can assume that
           the formal list is well-formal, which is to say actually a proper list
           of distinct symbols. */
        struct jitterlisp_interpreted_closure *ic = & c->interpreted;
        jitterlisp_object rest = ic->formals;
        jitter_uint in_arity = 0;
        while (! JITTERLISP_IS_EMPTY_LIST(rest))
          {
            in_arity ++;
            rest = JITTERLISP_EXP_C_A_CDR(rest);
          }
        if (in_arity != JITTER_ARGN0)
          JITTER_BRANCH_FAST(JITTER_ARGF1);
      }
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for !REPLACEMENT-check-in-arity--alt/n9/fR/retR . */

  //fprintf (stderr, "..Executed replacement instruction %s\n", "!REPLACEMENT-check-in-arity--alt/n9/fR/retR");
  //fprintf (stderr, "..Executed instruction %s\n", "!REPLACEMENT-check-in-arity--alt/n9/fR/retR");
//#endif // #if 0
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
#ifdef JITTER_REPLICATE
  {
    /* Advance the instruction pointer, if any, to skip every
       residual but the last; branch back to replicated
       code. */
    const void *_jitter_back_to_replicated_code_pointer =
      JITTER_ARGP2;
    JITTER_SKIP_RESIDUALS_;
    goto * _jitter_back_to_replicated_code_pointer;
  }
#endif // #ifdef JITTER_REPLICATE

    /* Undefine the !REPLACEMENT-check-in-arity--alt/n9/fR/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1
#   undef JITTER_SLOW_REGISTER_OFFSET2
#   undef JITTER_ARG2
#   undef JITTER_ARGN2
#   undef JITTER_ARGU2
#   undef JITTER_ARGP2
#   undef JITTER_ARGF2

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#ifndef JITTER_REPLICATE
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-check-in-arity--alt/n9/fR/retR, _eREPLACEMENT_mcheck_min_marity_m_malt__n9__fR__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#endif // #ifndef JITTER_REPLICATE
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for !REPLACEMENT-check-in-arity--alt/n9/fR/retR, which started with its
       definitions. */
  }
#endif // #if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
/*  End of !REPLACEMENT-check-in-arity--alt/n9/fR/retR , a replacement specialised instruction */

  /* Ordinary specialised instruction !REPLACEMENT-check-in-arity--alt/n10/fR/retR (replacement) */
  /* Omit this specialised instruction altogether unless
     replacements are in fact supported in this
     configuration. */
#if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
  JITTER_INSTRUCTION_PROLOG_(!REPLACEMENT-check-in-arity--alt/n10/fR/retR, _eREPLACEMENT_mcheck_min_marity_m_malt__n10__fR__retR, cold)
  { /* This block begins with definitions for !REPLACEMENT-check-in-arity--alt/n10/fR/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       284
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         !REPLACEMENT-check-in-arity--alt/n10/fR/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "check-in-arity--alt"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "!REPLACEMENT-check-in-arity--alt/n10/fR/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _eREPLACEMENT_mcheck_min_marity_m_malt__n10__fR__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is non-relocatable.
       Its 2-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST JITTER_BRANCH
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
    /* This specialized instruction is non-relocatable.
       Its 2-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 2

  /* Define argument-access macros for !REPLACEMENT-check-in-arity--alt/n10/fR/retR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 10L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

    /* The 2th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG2  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN2 (JITTER_ARG2.fixnum)
#   define JITTER_ARGU2 (JITTER_ARG2.ufixnum)
#   define JITTER_ARGP2 (JITTER_ARG2.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 10L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

    /* The 2th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG2  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN2 (JITTER_ARG2.fixnum)
#   define JITTER_ARGU2 (JITTER_ARG2.ufixnum)
#   define JITTER_ARGP2 (JITTER_ARG2.pointer)
#   define JITTER_ARGF2 JITTER_ARGP2

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* When jumping to the non-relocatable part it is important not
   to use a fallback version of JITTER_COMPUTED_GOTO, in order to
   prevent GCC from tail-merging. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
    /* Jump to non-relocatable code. */
    JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);

    /* Here the residual arity is given as zero: it's too late to
       skip residuals, since we've already jumped and this code is
       unreachable.  The instruction pointer, if any, is advanced
       in the non-relocatable code. */
    JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-check-in-arity--alt/n10/fR/retR, _eREPLACEMENT_mcheck_min_marity_m_malt__n10__fR__retR, 0)

    /* Relocated code will jump to this label in non-relocated code. */
  JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
    JITTER_COMMENT_IN_ASM_("!REPLACEMENT-check-in-arity--alt/n10/fR/retR non-relocatable code");
#endif // #ifdef JITTER_REPLICATE
#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of !REPLACEMENT-check-in-arity--alt/n10/fR/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  no. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
//#if 0
  //fprintf (stderr, "Executing instruction %s..\n", "!REPLACEMENT-check-in-arity--alt/n10/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing replacement instruction %s..\n", "!REPLACEMENT-check-in-arity--alt/n10/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing non-relocatable instruction %s with JITTER_SPECIALIZED_INSTRUCTION_WORD_NO=%i..\n", "!REPLACEMENT-check-in-arity--alt/n10/fR/retR", (int) JITTER_SPECIALIZED_INSTRUCTION_WORD_NO); fflush (stderr);
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#undef JITTER_THIS_IS_A_REPLACEMENT
#define JITTER_THIS_IS_A_REPLACEMENT 1

    /* User code for !REPLACEMENT-check-in-arity--alt/n10/fR/retR . */
  {
/* User-specified code, user code block part: beginning. */

    // FIXME: this loops forever with no-threading (not with the other dispatches
    // including minimal threading) when the callee is compiled.  A Jitter bug.
    /* Here we can assume that the top object is a closure, without checking: we either
       already performed a type check, or the compiler decided it wasn't necessary. */
    jitterlisp_object top = JITTER_TOP_MAINSTACK();
    struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(top);

    /* FIXME: this is optimizable.  I should store the in-arity as a field, independently
       from the closure compiledness.  [Done] */
    if (JITTERLISP_IS_COMPILED_CLOSURE(top))
      {
        if (c->in_arity != JITTER_ARGN0)
          JITTER_BRANCH_FAST(JITTER_ARGF1);
      }
    else
      {
        /* The closure is interpreted.  Compute its in-arity.  We can assume that
           the formal list is well-formal, which is to say actually a proper list
           of distinct symbols. */
        struct jitterlisp_interpreted_closure *ic = & c->interpreted;
        jitterlisp_object rest = ic->formals;
        jitter_uint in_arity = 0;
        while (! JITTERLISP_IS_EMPTY_LIST(rest))
          {
            in_arity ++;
            rest = JITTERLISP_EXP_C_A_CDR(rest);
          }
        if (in_arity != JITTER_ARGN0)
          JITTER_BRANCH_FAST(JITTER_ARGF1);
      }
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for !REPLACEMENT-check-in-arity--alt/n10/fR/retR . */

  //fprintf (stderr, "..Executed replacement instruction %s\n", "!REPLACEMENT-check-in-arity--alt/n10/fR/retR");
  //fprintf (stderr, "..Executed instruction %s\n", "!REPLACEMENT-check-in-arity--alt/n10/fR/retR");
//#endif // #if 0
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
#ifdef JITTER_REPLICATE
  {
    /* Advance the instruction pointer, if any, to skip every
       residual but the last; branch back to replicated
       code. */
    const void *_jitter_back_to_replicated_code_pointer =
      JITTER_ARGP2;
    JITTER_SKIP_RESIDUALS_;
    goto * _jitter_back_to_replicated_code_pointer;
  }
#endif // #ifdef JITTER_REPLICATE

    /* Undefine the !REPLACEMENT-check-in-arity--alt/n10/fR/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1
#   undef JITTER_SLOW_REGISTER_OFFSET2
#   undef JITTER_ARG2
#   undef JITTER_ARGN2
#   undef JITTER_ARGU2
#   undef JITTER_ARGP2
#   undef JITTER_ARGF2

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#ifndef JITTER_REPLICATE
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-check-in-arity--alt/n10/fR/retR, _eREPLACEMENT_mcheck_min_marity_m_malt__n10__fR__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#endif // #ifndef JITTER_REPLICATE
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for !REPLACEMENT-check-in-arity--alt/n10/fR/retR, which started with its
       definitions. */
  }
#endif // #if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
/*  End of !REPLACEMENT-check-in-arity--alt/n10/fR/retR , a replacement specialised instruction */

  /* Ordinary specialised instruction !REPLACEMENT-check-in-arity--alt/nR/fR/retR (replacement) */
  /* Omit this specialised instruction altogether unless
     replacements are in fact supported in this
     configuration. */
#if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
  JITTER_INSTRUCTION_PROLOG_(!REPLACEMENT-check-in-arity--alt/nR/fR/retR, _eREPLACEMENT_mcheck_min_marity_m_malt__nR__fR__retR, cold)
  { /* This block begins with definitions for !REPLACEMENT-check-in-arity--alt/nR/fR/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       285
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         !REPLACEMENT-check-in-arity--alt/nR/fR/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "check-in-arity--alt"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "!REPLACEMENT-check-in-arity--alt/nR/fR/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _eREPLACEMENT_mcheck_min_marity_m_malt__nR__fR__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is non-relocatable.
       Its 2-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST JITTER_BRANCH
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
    /* This specialized instruction is non-relocatable.
       Its 2-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 3

  /* Define argument-access macros for !REPLACEMENT-check-in-arity--alt/nR/fR/retR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a residual literal. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

    /* The 2th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG2  JITTER_RESIDUAL_ARGUMENT_2
    JITTER_MARK_RESIDUAL_2_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[2])
#else
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[3])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN2 (JITTER_ARG2.fixnum)
#   define JITTER_ARGU2 (JITTER_ARG2.ufixnum)
#   define JITTER_ARGP2 (JITTER_ARG2.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
    /* The 0th argument is a residual literal. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

    /* The 2th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG2  JITTER_RESIDUAL_ARGUMENT_2
    JITTER_MARK_RESIDUAL_2_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[2])
#else
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[3])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN2 (JITTER_ARG2.fixnum)
#   define JITTER_ARGU2 (JITTER_ARG2.ufixnum)
#   define JITTER_ARGP2 (JITTER_ARG2.pointer)
#   define JITTER_ARGF2 JITTER_ARGP2

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* When jumping to the non-relocatable part it is important not
   to use a fallback version of JITTER_COMPUTED_GOTO, in order to
   prevent GCC from tail-merging. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
    /* Jump to non-relocatable code. */
    JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);

    /* Here the residual arity is given as zero: it's too late to
       skip residuals, since we've already jumped and this code is
       unreachable.  The instruction pointer, if any, is advanced
       in the non-relocatable code. */
    JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-check-in-arity--alt/nR/fR/retR, _eREPLACEMENT_mcheck_min_marity_m_malt__nR__fR__retR, 0)

    /* Relocated code will jump to this label in non-relocated code. */
  JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
    JITTER_COMMENT_IN_ASM_("!REPLACEMENT-check-in-arity--alt/nR/fR/retR non-relocatable code");
#endif // #ifdef JITTER_REPLICATE
#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of !REPLACEMENT-check-in-arity--alt/nR/fR/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  no. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
//#if 0
  //fprintf (stderr, "Executing instruction %s..\n", "!REPLACEMENT-check-in-arity--alt/nR/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing replacement instruction %s..\n", "!REPLACEMENT-check-in-arity--alt/nR/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing non-relocatable instruction %s with JITTER_SPECIALIZED_INSTRUCTION_WORD_NO=%i..\n", "!REPLACEMENT-check-in-arity--alt/nR/fR/retR", (int) JITTER_SPECIALIZED_INSTRUCTION_WORD_NO); fflush (stderr);
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#undef JITTER_THIS_IS_A_REPLACEMENT
#define JITTER_THIS_IS_A_REPLACEMENT 1

    /* User code for !REPLACEMENT-check-in-arity--alt/nR/fR/retR . */
  {
/* User-specified code, user code block part: beginning. */

    // FIXME: this loops forever with no-threading (not with the other dispatches
    // including minimal threading) when the callee is compiled.  A Jitter bug.
    /* Here we can assume that the top object is a closure, without checking: we either
       already performed a type check, or the compiler decided it wasn't necessary. */
    jitterlisp_object top = JITTER_TOP_MAINSTACK();
    struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(top);

    /* FIXME: this is optimizable.  I should store the in-arity as a field, independently
       from the closure compiledness.  [Done] */
    if (JITTERLISP_IS_COMPILED_CLOSURE(top))
      {
        if (c->in_arity != JITTER_ARGN0)
          JITTER_BRANCH_FAST(JITTER_ARGF1);
      }
    else
      {
        /* The closure is interpreted.  Compute its in-arity.  We can assume that
           the formal list is well-formal, which is to say actually a proper list
           of distinct symbols. */
        struct jitterlisp_interpreted_closure *ic = & c->interpreted;
        jitterlisp_object rest = ic->formals;
        jitter_uint in_arity = 0;
        while (! JITTERLISP_IS_EMPTY_LIST(rest))
          {
            in_arity ++;
            rest = JITTERLISP_EXP_C_A_CDR(rest);
          }
        if (in_arity != JITTER_ARGN0)
          JITTER_BRANCH_FAST(JITTER_ARGF1);
      }
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for !REPLACEMENT-check-in-arity--alt/nR/fR/retR . */

  //fprintf (stderr, "..Executed replacement instruction %s\n", "!REPLACEMENT-check-in-arity--alt/nR/fR/retR");
  //fprintf (stderr, "..Executed instruction %s\n", "!REPLACEMENT-check-in-arity--alt/nR/fR/retR");
//#endif // #if 0
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
#ifdef JITTER_REPLICATE
  {
    /* Advance the instruction pointer, if any, to skip every
       residual but the last; branch back to replicated
       code. */
    const void *_jitter_back_to_replicated_code_pointer =
      JITTER_ARGP2;
    JITTER_SKIP_RESIDUALS_;
    goto * _jitter_back_to_replicated_code_pointer;
  }
#endif // #ifdef JITTER_REPLICATE

    /* Undefine the !REPLACEMENT-check-in-arity--alt/nR/fR/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1
#   undef JITTER_SLOW_REGISTER_OFFSET2
#   undef JITTER_ARG2
#   undef JITTER_ARGN2
#   undef JITTER_ARGU2
#   undef JITTER_ARGP2
#   undef JITTER_ARGF2

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#ifndef JITTER_REPLICATE
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-check-in-arity--alt/nR/fR/retR, _eREPLACEMENT_mcheck_min_marity_m_malt__nR__fR__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#endif // #ifndef JITTER_REPLICATE
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for !REPLACEMENT-check-in-arity--alt/nR/fR/retR, which started with its
       definitions. */
  }
#endif // #if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
/*  End of !REPLACEMENT-check-in-arity--alt/nR/fR/retR , a replacement specialised instruction */

  /* Ordinary specialised instruction !REPLACEMENT-exitvm/retR (replacement) */
  /* Omit this specialised instruction altogether unless
     replacements are in fact supported in this
     configuration. */
#if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
  JITTER_INSTRUCTION_PROLOG_(!REPLACEMENT-exitvm/retR, _eREPLACEMENT_mexitvm__retR, cold)
  { /* This block begins with definitions for !REPLACEMENT-exitvm/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       286
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         !REPLACEMENT-exitvm/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "exitvm"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "!REPLACEMENT-exitvm/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _eREPLACEMENT_mexitvm__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is non-relocatable.
       Its 0-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is non-relocatable.
       Its 0-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1

    /* The 0th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0


#ifdef JITTER_REPLICATE
/* When jumping to the non-relocatable part it is important not
   to use a fallback version of JITTER_COMPUTED_GOTO, in order to
   prevent GCC from tail-merging. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
    /* Jump to non-relocatable code. */
    JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);

    /* Here the residual arity is given as zero: it's too late to
       skip residuals, since we've already jumped and this code is
       unreachable.  The instruction pointer, if any, is advanced
       in the non-relocatable code. */
    JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-exitvm/retR, _eREPLACEMENT_mexitvm__retR, 0)

    /* Relocated code will jump to this label in non-relocated code. */
  JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
    JITTER_COMMENT_IN_ASM_("!REPLACEMENT-exitvm/retR non-relocatable code");
#endif // #ifdef JITTER_REPLICATE
#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of !REPLACEMENT-exitvm/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  no. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
//#if 0
  //fprintf (stderr, "Executing instruction %s..\n", "!REPLACEMENT-exitvm/retR"); fflush (stderr);
  //fprintf (stderr, "Executing replacement instruction %s..\n", "!REPLACEMENT-exitvm/retR"); fflush (stderr);
  //fprintf (stderr, "Executing non-relocatable instruction %s with JITTER_SPECIALIZED_INSTRUCTION_WORD_NO=%i..\n", "!REPLACEMENT-exitvm/retR", (int) JITTER_SPECIALIZED_INSTRUCTION_WORD_NO); fflush (stderr);
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#undef JITTER_THIS_IS_A_REPLACEMENT
#define JITTER_THIS_IS_A_REPLACEMENT 1

    /* User code for !REPLACEMENT-exitvm/retR . */
  {
/* User-specified code, user code block part: beginning. */
JITTER_EXIT();
/* User-specified code, user code block part: end */

  }
    /* End of the user code for !REPLACEMENT-exitvm/retR . */

  //fprintf (stderr, "..Executed replacement instruction %s\n", "!REPLACEMENT-exitvm/retR");
  //fprintf (stderr, "..Executed instruction %s\n", "!REPLACEMENT-exitvm/retR");
//#endif // #if 0
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
#ifdef JITTER_REPLICATE
  {
    /* Advance the instruction pointer, if any, to skip every
       residual but the last; branch back to replicated
       code. */
    const void *_jitter_back_to_replicated_code_pointer =
      JITTER_ARGP0;
    JITTER_SKIP_RESIDUALS_;
    goto * _jitter_back_to_replicated_code_pointer;
  }
#endif // #ifdef JITTER_REPLICATE

    /* Undefine the !REPLACEMENT-exitvm/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#ifndef JITTER_REPLICATE
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-exitvm/retR, _eREPLACEMENT_mexitvm__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#endif // #ifndef JITTER_REPLICATE
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for !REPLACEMENT-exitvm/retR, which started with its
       definitions. */
  }
#endif // #if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
/*  End of !REPLACEMENT-exitvm/retR , a replacement specialised instruction */

  /* Ordinary specialised instruction !REPLACEMENT-gc-if-needed/fR/retR (replacement) */
  /* Omit this specialised instruction altogether unless
     replacements are in fact supported in this
     configuration. */
#if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
  JITTER_INSTRUCTION_PROLOG_(!REPLACEMENT-gc-if-needed/fR/retR, _eREPLACEMENT_mgc_mif_mneeded__fR__retR, cold)
  { /* This block begins with definitions for !REPLACEMENT-gc-if-needed/fR/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       287
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         !REPLACEMENT-gc-if-needed/fR/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "gc-if-needed"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "!REPLACEMENT-gc-if-needed/fR/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _eREPLACEMENT_mgc_mif_mneeded__fR__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST JITTER_BRANCH
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 2

  /* Define argument-access macros for !REPLACEMENT-gc-if-needed/fR/retR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
    /* The 0th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* When jumping to the non-relocatable part it is important not
   to use a fallback version of JITTER_COMPUTED_GOTO, in order to
   prevent GCC from tail-merging. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
    /* Jump to non-relocatable code. */
    JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);

    /* Here the residual arity is given as zero: it's too late to
       skip residuals, since we've already jumped and this code is
       unreachable.  The instruction pointer, if any, is advanced
       in the non-relocatable code. */
    JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-gc-if-needed/fR/retR, _eREPLACEMENT_mgc_mif_mneeded__fR__retR, 0)

    /* Relocated code will jump to this label in non-relocated code. */
  JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
    JITTER_COMMENT_IN_ASM_("!REPLACEMENT-gc-if-needed/fR/retR non-relocatable code");
#endif // #ifdef JITTER_REPLICATE
#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of !REPLACEMENT-gc-if-needed/fR/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  no. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
//#if 0
  //fprintf (stderr, "Executing instruction %s..\n", "!REPLACEMENT-gc-if-needed/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing replacement instruction %s..\n", "!REPLACEMENT-gc-if-needed/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing non-relocatable instruction %s with JITTER_SPECIALIZED_INSTRUCTION_WORD_NO=%i..\n", "!REPLACEMENT-gc-if-needed/fR/retR", (int) JITTER_SPECIALIZED_INSTRUCTION_WORD_NO); fflush (stderr);
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#undef JITTER_THIS_IS_A_REPLACEMENT
#define JITTER_THIS_IS_A_REPLACEMENT 1

    /* User code for !REPLACEMENT-gc-if-needed/fR/retR . */
  {
/* User-specified code, user code block part: beginning. */

#ifdef JITTER_GC_STUB
    /* FIXME: I might want to merge this, along with the body of other
       instructions, into a macro.  This may still be factored in a different
       way, but the idea looks correct and promising. */
    /* Branch to the slow path of the allocation, which includes a minor GC,
       in case the allocation pointer is now out of the nursery.  Do nothing
       otherwise.
       Rationale: separating branches from instructions having effect on the VM
       state prevents defective instructions; even if I have reason to believe
       that this particular state effect (unconditionally incrementing a runtime
       field) is not problematic with respect to defects, I will need to seriously
       stress the system after defect replacement is really implemented. */
    JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
       (JITTERLISPVM_STATE_RUNTIME_FIELD (allocation_next),
        JITTERLISPVM_STATE_RUNTIME_FIELD (allocation_limit),
        JITTER_ARGF0);
#else
    /* Nothing to do.  With the ordinary non-stub heap all the actual
       memory allocation happens in primitive-cons-special. */
#endif //#ifdef JITTER_GC_STUB
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for !REPLACEMENT-gc-if-needed/fR/retR . */

  //fprintf (stderr, "..Executed replacement instruction %s\n", "!REPLACEMENT-gc-if-needed/fR/retR");
  //fprintf (stderr, "..Executed instruction %s\n", "!REPLACEMENT-gc-if-needed/fR/retR");
//#endif // #if 0
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
#ifdef JITTER_REPLICATE
  {
    /* Advance the instruction pointer, if any, to skip every
       residual but the last; branch back to replicated
       code. */
    const void *_jitter_back_to_replicated_code_pointer =
      JITTER_ARGP1;
    JITTER_SKIP_RESIDUALS_;
    goto * _jitter_back_to_replicated_code_pointer;
  }
#endif // #ifdef JITTER_REPLICATE

    /* Undefine the !REPLACEMENT-gc-if-needed/fR/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#ifndef JITTER_REPLICATE
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-gc-if-needed/fR/retR, _eREPLACEMENT_mgc_mif_mneeded__fR__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#endif // #ifndef JITTER_REPLICATE
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for !REPLACEMENT-gc-if-needed/fR/retR, which started with its
       definitions. */
  }
#endif // #if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
/*  End of !REPLACEMENT-gc-if-needed/fR/retR , a replacement specialised instruction */

  /* Ordinary specialised instruction !REPLACEMENT-one-minus-register/%rR/%rR/fR/retR (replacement) */
  /* Omit this specialised instruction altogether unless
     replacements are in fact supported in this
     configuration. */
#if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
  JITTER_INSTRUCTION_PROLOG_(!REPLACEMENT-one-minus-register/%rR/%rR/fR/retR, _eREPLACEMENT_mone_mminus_mregister___rrR___rrR__fR__retR, cold)
  { /* This block begins with definitions for !REPLACEMENT-one-minus-register/%rR/%rR/fR/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       288
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         !REPLACEMENT-one-minus-register/%rR/%rR/fR/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "one-minus-register"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "!REPLACEMENT-one-minus-register/%rR/%rR/fR/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _eREPLACEMENT_mone_mminus_mregister___rrR___rrR__fR__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is non-relocatable.
       Its 3-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST JITTER_BRANCH
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
    /* This specialized instruction is non-relocatable.
       Its 3-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 4

  /* Define argument-access macros for !REPLACEMENT-one-minus-register/%rR/%rR/fR/retR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a slow (therefore residual, passed as an offset)
        register. */
  /* Define a macro expanding to the slow register offset. */
#if defined(JITTER_DISPATCH_NO_THREADING)
# define JITTER_SLOW_REGISTER_OFFSET0 (JITTER_RESIDUAL_ARGUMENT_0.fixnum)
#elif defined (JITTER_DISPATCH_MINIMAL_THREADING)
# define JITTER_SLOW_REGISTER_OFFSET0 ((((union jitter_word*)jitter_ip)[0]).fixnum)
#else
# define JITTER_SLOW_REGISTER_OFFSET0 ((((union jitter_word*)jitter_ip)[1]).fixnum)
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
  /* Define a macro expanding to an l-value for the VM register content. */
#   define JITTER_ARG0  JITTER_SLOW_REGISTER_FROM_OFFSET(r, JITTER_SLOW_REGISTER_OFFSET0)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)

    /* The 1th argument is a slow (therefore residual, passed as an offset)
        register. */
  /* Define a macro expanding to the slow register offset. */
#if defined(JITTER_DISPATCH_NO_THREADING)
# define JITTER_SLOW_REGISTER_OFFSET1 (JITTER_RESIDUAL_ARGUMENT_1.fixnum)
#elif defined (JITTER_DISPATCH_MINIMAL_THREADING)
# define JITTER_SLOW_REGISTER_OFFSET1 ((((union jitter_word*)jitter_ip)[1]).fixnum)
#else
# define JITTER_SLOW_REGISTER_OFFSET1 ((((union jitter_word*)jitter_ip)[2]).fixnum)
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
  /* Define a macro expanding to an l-value for the VM register content. */
#   define JITTER_ARG1  JITTER_SLOW_REGISTER_FROM_OFFSET(r, JITTER_SLOW_REGISTER_OFFSET1)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)

    /* The 2th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG2  JITTER_RESIDUAL_ARGUMENT_2
    JITTER_MARK_RESIDUAL_2_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[2])
#else
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[3])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN2 (JITTER_ARG2.fixnum)
#   define JITTER_ARGU2 (JITTER_ARG2.ufixnum)
#   define JITTER_ARGP2 (JITTER_ARG2.pointer)
#   define JITTER_ARGF2 JITTER_ARGP2

    /* The 3th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG3  JITTER_RESIDUAL_ARGUMENT_3
    JITTER_MARK_RESIDUAL_3_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG3  (((union jitter_word*)jitter_ip)[3])
#else
#   define JITTER_ARG3  (((union jitter_word*)jitter_ip)[4])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN3 (JITTER_ARG3.fixnum)
#   define JITTER_ARGU3 (JITTER_ARG3.ufixnum)
#   define JITTER_ARGP3 (JITTER_ARG3.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
    /* The 0th argument is a slow (therefore residual, passed as an offset)
        register. */
  /* Define a macro expanding to the slow register offset. */
#if defined(JITTER_DISPATCH_NO_THREADING)
# define JITTER_SLOW_REGISTER_OFFSET0 (JITTER_RESIDUAL_ARGUMENT_0.fixnum)
#elif defined (JITTER_DISPATCH_MINIMAL_THREADING)
# define JITTER_SLOW_REGISTER_OFFSET0 ((((union jitter_word*)jitter_ip)[0]).fixnum)
#else
# define JITTER_SLOW_REGISTER_OFFSET0 ((((union jitter_word*)jitter_ip)[1]).fixnum)
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
  /* Define a macro expanding to an l-value for the VM register content. */
#   define JITTER_ARG0  JITTER_SLOW_REGISTER_FROM_OFFSET(r, JITTER_SLOW_REGISTER_OFFSET0)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a slow (therefore residual, passed as an offset)
        register. */
  /* Define a macro expanding to the slow register offset. */
#if defined(JITTER_DISPATCH_NO_THREADING)
# define JITTER_SLOW_REGISTER_OFFSET1 (JITTER_RESIDUAL_ARGUMENT_1.fixnum)
#elif defined (JITTER_DISPATCH_MINIMAL_THREADING)
# define JITTER_SLOW_REGISTER_OFFSET1 ((((union jitter_word*)jitter_ip)[1]).fixnum)
#else
# define JITTER_SLOW_REGISTER_OFFSET1 ((((union jitter_word*)jitter_ip)[2]).fixnum)
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
  /* Define a macro expanding to an l-value for the VM register content. */
#   define JITTER_ARG1  JITTER_SLOW_REGISTER_FROM_OFFSET(r, JITTER_SLOW_REGISTER_OFFSET1)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

    /* The 2th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG2  JITTER_RESIDUAL_ARGUMENT_2
    JITTER_MARK_RESIDUAL_2_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[2])
#else
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[3])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN2 (JITTER_ARG2.fixnum)
#   define JITTER_ARGU2 (JITTER_ARG2.ufixnum)
#   define JITTER_ARGP2 (JITTER_ARG2.pointer)
#   define JITTER_ARGF2 JITTER_ARGP2

    /* The 3th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG3  JITTER_RESIDUAL_ARGUMENT_3
    JITTER_MARK_RESIDUAL_3_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG3  (((union jitter_word*)jitter_ip)[3])
#else
#   define JITTER_ARG3  (((union jitter_word*)jitter_ip)[4])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN3 (JITTER_ARG3.fixnum)
#   define JITTER_ARGU3 (JITTER_ARG3.ufixnum)
#   define JITTER_ARGP3 (JITTER_ARG3.pointer)
#   define JITTER_ARGF3 JITTER_ARGP3

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* When jumping to the non-relocatable part it is important not
   to use a fallback version of JITTER_COMPUTED_GOTO, in order to
   prevent GCC from tail-merging. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
    /* Jump to non-relocatable code. */
    JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);

    /* Here the residual arity is given as zero: it's too late to
       skip residuals, since we've already jumped and this code is
       unreachable.  The instruction pointer, if any, is advanced
       in the non-relocatable code. */
    JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-one-minus-register/%rR/%rR/fR/retR, _eREPLACEMENT_mone_mminus_mregister___rrR___rrR__fR__retR, 0)

    /* Relocated code will jump to this label in non-relocated code. */
  JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
    JITTER_COMMENT_IN_ASM_("!REPLACEMENT-one-minus-register/%rR/%rR/fR/retR non-relocatable code");
#endif // #ifdef JITTER_REPLICATE
#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of !REPLACEMENT-one-minus-register/%rR/%rR/fR/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  no. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
//#if 0
  //fprintf (stderr, "Executing instruction %s..\n", "!REPLACEMENT-one-minus-register/%rR/%rR/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing replacement instruction %s..\n", "!REPLACEMENT-one-minus-register/%rR/%rR/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing non-relocatable instruction %s with JITTER_SPECIALIZED_INSTRUCTION_WORD_NO=%i..\n", "!REPLACEMENT-one-minus-register/%rR/%rR/fR/retR", (int) JITTER_SPECIALIZED_INSTRUCTION_WORD_NO); fflush (stderr);
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#undef JITTER_THIS_IS_A_REPLACEMENT
#define JITTER_THIS_IS_A_REPLACEMENT 1

    /* User code for !REPLACEMENT-one-minus-register/%rR/%rR/fR/retR . */
  {
/* User-specified code, user code block part: beginning. */

#if ! defined (JITTERLISP_UNSAFE)
    JITTERLISP_BRANCH_FAST_UNLESS_FIXNUM (JITTER_ARG0, JITTER_ARGF2);
#endif
    JITTERLISP_1MINUS_OR_OVERFLOW_(JITTER_ARG1,
                                   JITTER_ARG0,
                                   JITTER_ARGF2);
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for !REPLACEMENT-one-minus-register/%rR/%rR/fR/retR . */

  //fprintf (stderr, "..Executed replacement instruction %s\n", "!REPLACEMENT-one-minus-register/%rR/%rR/fR/retR");
  //fprintf (stderr, "..Executed instruction %s\n", "!REPLACEMENT-one-minus-register/%rR/%rR/fR/retR");
//#endif // #if 0
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
#ifdef JITTER_REPLICATE
  {
    /* Advance the instruction pointer, if any, to skip every
       residual but the last; branch back to replicated
       code. */
    const void *_jitter_back_to_replicated_code_pointer =
      JITTER_ARGP3;
    JITTER_SKIP_RESIDUALS_;
    goto * _jitter_back_to_replicated_code_pointer;
  }
#endif // #ifdef JITTER_REPLICATE

    /* Undefine the !REPLACEMENT-one-minus-register/%rR/%rR/fR/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1
#   undef JITTER_SLOW_REGISTER_OFFSET2
#   undef JITTER_ARG2
#   undef JITTER_ARGN2
#   undef JITTER_ARGU2
#   undef JITTER_ARGP2
#   undef JITTER_ARGF2
#   undef JITTER_SLOW_REGISTER_OFFSET3
#   undef JITTER_ARG3
#   undef JITTER_ARGN3
#   undef JITTER_ARGU3
#   undef JITTER_ARGP3
#   undef JITTER_ARGF3

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#ifndef JITTER_REPLICATE
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-one-minus-register/%rR/%rR/fR/retR, _eREPLACEMENT_mone_mminus_mregister___rrR___rrR__fR__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#endif // #ifndef JITTER_REPLICATE
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for !REPLACEMENT-one-minus-register/%rR/%rR/fR/retR, which started with its
       definitions. */
  }
#endif // #if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
/*  End of !REPLACEMENT-one-minus-register/%rR/%rR/fR/retR , a replacement specialised instruction */

  /* Ordinary specialised instruction !REPLACEMENT-one-plus-register/%rR/%rR/fR/retR (replacement) */
  /* Omit this specialised instruction altogether unless
     replacements are in fact supported in this
     configuration. */
#if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
  JITTER_INSTRUCTION_PROLOG_(!REPLACEMENT-one-plus-register/%rR/%rR/fR/retR, _eREPLACEMENT_mone_mplus_mregister___rrR___rrR__fR__retR, cold)
  { /* This block begins with definitions for !REPLACEMENT-one-plus-register/%rR/%rR/fR/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       289
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         !REPLACEMENT-one-plus-register/%rR/%rR/fR/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "one-plus-register"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "!REPLACEMENT-one-plus-register/%rR/%rR/fR/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _eREPLACEMENT_mone_mplus_mregister___rrR___rrR__fR__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is non-relocatable.
       Its 3-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST JITTER_BRANCH
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
    /* This specialized instruction is non-relocatable.
       Its 3-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 4

  /* Define argument-access macros for !REPLACEMENT-one-plus-register/%rR/%rR/fR/retR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a slow (therefore residual, passed as an offset)
        register. */
  /* Define a macro expanding to the slow register offset. */
#if defined(JITTER_DISPATCH_NO_THREADING)
# define JITTER_SLOW_REGISTER_OFFSET0 (JITTER_RESIDUAL_ARGUMENT_0.fixnum)
#elif defined (JITTER_DISPATCH_MINIMAL_THREADING)
# define JITTER_SLOW_REGISTER_OFFSET0 ((((union jitter_word*)jitter_ip)[0]).fixnum)
#else
# define JITTER_SLOW_REGISTER_OFFSET0 ((((union jitter_word*)jitter_ip)[1]).fixnum)
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
  /* Define a macro expanding to an l-value for the VM register content. */
#   define JITTER_ARG0  JITTER_SLOW_REGISTER_FROM_OFFSET(r, JITTER_SLOW_REGISTER_OFFSET0)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)

    /* The 1th argument is a slow (therefore residual, passed as an offset)
        register. */
  /* Define a macro expanding to the slow register offset. */
#if defined(JITTER_DISPATCH_NO_THREADING)
# define JITTER_SLOW_REGISTER_OFFSET1 (JITTER_RESIDUAL_ARGUMENT_1.fixnum)
#elif defined (JITTER_DISPATCH_MINIMAL_THREADING)
# define JITTER_SLOW_REGISTER_OFFSET1 ((((union jitter_word*)jitter_ip)[1]).fixnum)
#else
# define JITTER_SLOW_REGISTER_OFFSET1 ((((union jitter_word*)jitter_ip)[2]).fixnum)
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
  /* Define a macro expanding to an l-value for the VM register content. */
#   define JITTER_ARG1  JITTER_SLOW_REGISTER_FROM_OFFSET(r, JITTER_SLOW_REGISTER_OFFSET1)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)

    /* The 2th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG2  JITTER_RESIDUAL_ARGUMENT_2
    JITTER_MARK_RESIDUAL_2_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[2])
#else
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[3])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN2 (JITTER_ARG2.fixnum)
#   define JITTER_ARGU2 (JITTER_ARG2.ufixnum)
#   define JITTER_ARGP2 (JITTER_ARG2.pointer)
#   define JITTER_ARGF2 JITTER_ARGP2

    /* The 3th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG3  JITTER_RESIDUAL_ARGUMENT_3
    JITTER_MARK_RESIDUAL_3_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG3  (((union jitter_word*)jitter_ip)[3])
#else
#   define JITTER_ARG3  (((union jitter_word*)jitter_ip)[4])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN3 (JITTER_ARG3.fixnum)
#   define JITTER_ARGU3 (JITTER_ARG3.ufixnum)
#   define JITTER_ARGP3 (JITTER_ARG3.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
    /* The 0th argument is a slow (therefore residual, passed as an offset)
        register. */
  /* Define a macro expanding to the slow register offset. */
#if defined(JITTER_DISPATCH_NO_THREADING)
# define JITTER_SLOW_REGISTER_OFFSET0 (JITTER_RESIDUAL_ARGUMENT_0.fixnum)
#elif defined (JITTER_DISPATCH_MINIMAL_THREADING)
# define JITTER_SLOW_REGISTER_OFFSET0 ((((union jitter_word*)jitter_ip)[0]).fixnum)
#else
# define JITTER_SLOW_REGISTER_OFFSET0 ((((union jitter_word*)jitter_ip)[1]).fixnum)
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
  /* Define a macro expanding to an l-value for the VM register content. */
#   define JITTER_ARG0  JITTER_SLOW_REGISTER_FROM_OFFSET(r, JITTER_SLOW_REGISTER_OFFSET0)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a slow (therefore residual, passed as an offset)
        register. */
  /* Define a macro expanding to the slow register offset. */
#if defined(JITTER_DISPATCH_NO_THREADING)
# define JITTER_SLOW_REGISTER_OFFSET1 (JITTER_RESIDUAL_ARGUMENT_1.fixnum)
#elif defined (JITTER_DISPATCH_MINIMAL_THREADING)
# define JITTER_SLOW_REGISTER_OFFSET1 ((((union jitter_word*)jitter_ip)[1]).fixnum)
#else
# define JITTER_SLOW_REGISTER_OFFSET1 ((((union jitter_word*)jitter_ip)[2]).fixnum)
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
  /* Define a macro expanding to an l-value for the VM register content. */
#   define JITTER_ARG1  JITTER_SLOW_REGISTER_FROM_OFFSET(r, JITTER_SLOW_REGISTER_OFFSET1)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

    /* The 2th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG2  JITTER_RESIDUAL_ARGUMENT_2
    JITTER_MARK_RESIDUAL_2_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[2])
#else
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[3])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN2 (JITTER_ARG2.fixnum)
#   define JITTER_ARGU2 (JITTER_ARG2.ufixnum)
#   define JITTER_ARGP2 (JITTER_ARG2.pointer)
#   define JITTER_ARGF2 JITTER_ARGP2

    /* The 3th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG3  JITTER_RESIDUAL_ARGUMENT_3
    JITTER_MARK_RESIDUAL_3_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG3  (((union jitter_word*)jitter_ip)[3])
#else
#   define JITTER_ARG3  (((union jitter_word*)jitter_ip)[4])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN3 (JITTER_ARG3.fixnum)
#   define JITTER_ARGU3 (JITTER_ARG3.ufixnum)
#   define JITTER_ARGP3 (JITTER_ARG3.pointer)
#   define JITTER_ARGF3 JITTER_ARGP3

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* When jumping to the non-relocatable part it is important not
   to use a fallback version of JITTER_COMPUTED_GOTO, in order to
   prevent GCC from tail-merging. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
    /* Jump to non-relocatable code. */
    JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);

    /* Here the residual arity is given as zero: it's too late to
       skip residuals, since we've already jumped and this code is
       unreachable.  The instruction pointer, if any, is advanced
       in the non-relocatable code. */
    JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-one-plus-register/%rR/%rR/fR/retR, _eREPLACEMENT_mone_mplus_mregister___rrR___rrR__fR__retR, 0)

    /* Relocated code will jump to this label in non-relocated code. */
  JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
    JITTER_COMMENT_IN_ASM_("!REPLACEMENT-one-plus-register/%rR/%rR/fR/retR non-relocatable code");
#endif // #ifdef JITTER_REPLICATE
#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of !REPLACEMENT-one-plus-register/%rR/%rR/fR/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  no. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
//#if 0
  //fprintf (stderr, "Executing instruction %s..\n", "!REPLACEMENT-one-plus-register/%rR/%rR/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing replacement instruction %s..\n", "!REPLACEMENT-one-plus-register/%rR/%rR/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing non-relocatable instruction %s with JITTER_SPECIALIZED_INSTRUCTION_WORD_NO=%i..\n", "!REPLACEMENT-one-plus-register/%rR/%rR/fR/retR", (int) JITTER_SPECIALIZED_INSTRUCTION_WORD_NO); fflush (stderr);
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#undef JITTER_THIS_IS_A_REPLACEMENT
#define JITTER_THIS_IS_A_REPLACEMENT 1

    /* User code for !REPLACEMENT-one-plus-register/%rR/%rR/fR/retR . */
  {
/* User-specified code, user code block part: beginning. */

#if ! defined (JITTERLISP_UNSAFE)
    JITTERLISP_BRANCH_FAST_UNLESS_FIXNUM (JITTER_ARG0, JITTER_ARGF2);
#endif
    JITTERLISP_1PLUS_OR_OVERFLOW_(JITTER_ARG1,
                                  JITTER_ARG0,
                                  JITTER_ARGF2);
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for !REPLACEMENT-one-plus-register/%rR/%rR/fR/retR . */

  //fprintf (stderr, "..Executed replacement instruction %s\n", "!REPLACEMENT-one-plus-register/%rR/%rR/fR/retR");
  //fprintf (stderr, "..Executed instruction %s\n", "!REPLACEMENT-one-plus-register/%rR/%rR/fR/retR");
//#endif // #if 0
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
#ifdef JITTER_REPLICATE
  {
    /* Advance the instruction pointer, if any, to skip every
       residual but the last; branch back to replicated
       code. */
    const void *_jitter_back_to_replicated_code_pointer =
      JITTER_ARGP3;
    JITTER_SKIP_RESIDUALS_;
    goto * _jitter_back_to_replicated_code_pointer;
  }
#endif // #ifdef JITTER_REPLICATE

    /* Undefine the !REPLACEMENT-one-plus-register/%rR/%rR/fR/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1
#   undef JITTER_SLOW_REGISTER_OFFSET2
#   undef JITTER_ARG2
#   undef JITTER_ARGN2
#   undef JITTER_ARGU2
#   undef JITTER_ARGP2
#   undef JITTER_ARGF2
#   undef JITTER_SLOW_REGISTER_OFFSET3
#   undef JITTER_ARG3
#   undef JITTER_ARGN3
#   undef JITTER_ARGU3
#   undef JITTER_ARGP3
#   undef JITTER_ARGF3

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#ifndef JITTER_REPLICATE
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-one-plus-register/%rR/%rR/fR/retR, _eREPLACEMENT_mone_mplus_mregister___rrR___rrR__fR__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#endif // #ifndef JITTER_REPLICATE
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for !REPLACEMENT-one-plus-register/%rR/%rR/fR/retR, which started with its
       definitions. */
  }
#endif // #if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
/*  End of !REPLACEMENT-one-plus-register/%rR/%rR/fR/retR , a replacement specialised instruction */

  /* Ordinary specialised instruction !REPLACEMENT-pop-to-global/nR/fR/retR (replacement) */
  /* Omit this specialised instruction altogether unless
     replacements are in fact supported in this
     configuration. */
#if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
  JITTER_INSTRUCTION_PROLOG_(!REPLACEMENT-pop-to-global/nR/fR/retR, _eREPLACEMENT_mpop_mto_mglobal__nR__fR__retR, cold)
  { /* This block begins with definitions for !REPLACEMENT-pop-to-global/nR/fR/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       290
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         !REPLACEMENT-pop-to-global/nR/fR/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "pop-to-global"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "!REPLACEMENT-pop-to-global/nR/fR/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _eREPLACEMENT_mpop_mto_mglobal__nR__fR__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is non-relocatable.
       Its 2-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST JITTER_BRANCH
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
    /* This specialized instruction is non-relocatable.
       Its 2-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 3

  /* Define argument-access macros for !REPLACEMENT-pop-to-global/nR/fR/retR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a residual literal. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

    /* The 2th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG2  JITTER_RESIDUAL_ARGUMENT_2
    JITTER_MARK_RESIDUAL_2_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[2])
#else
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[3])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN2 (JITTER_ARG2.fixnum)
#   define JITTER_ARGU2 (JITTER_ARG2.ufixnum)
#   define JITTER_ARGP2 (JITTER_ARG2.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
    /* The 0th argument is a residual literal. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

    /* The 2th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG2  JITTER_RESIDUAL_ARGUMENT_2
    JITTER_MARK_RESIDUAL_2_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[2])
#else
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[3])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN2 (JITTER_ARG2.fixnum)
#   define JITTER_ARGU2 (JITTER_ARG2.ufixnum)
#   define JITTER_ARGP2 (JITTER_ARG2.pointer)
#   define JITTER_ARGF2 JITTER_ARGP2

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* When jumping to the non-relocatable part it is important not
   to use a fallback version of JITTER_COMPUTED_GOTO, in order to
   prevent GCC from tail-merging. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
    /* Jump to non-relocatable code. */
    JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);

    /* Here the residual arity is given as zero: it's too late to
       skip residuals, since we've already jumped and this code is
       unreachable.  The instruction pointer, if any, is advanced
       in the non-relocatable code. */
    JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-pop-to-global/nR/fR/retR, _eREPLACEMENT_mpop_mto_mglobal__nR__fR__retR, 0)

    /* Relocated code will jump to this label in non-relocated code. */
  JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
    JITTER_COMMENT_IN_ASM_("!REPLACEMENT-pop-to-global/nR/fR/retR non-relocatable code");
#endif // #ifdef JITTER_REPLICATE
#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of !REPLACEMENT-pop-to-global/nR/fR/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  no. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
//#if 0
  //fprintf (stderr, "Executing instruction %s..\n", "!REPLACEMENT-pop-to-global/nR/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing replacement instruction %s..\n", "!REPLACEMENT-pop-to-global/nR/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing non-relocatable instruction %s with JITTER_SPECIALIZED_INSTRUCTION_WORD_NO=%i..\n", "!REPLACEMENT-pop-to-global/nR/fR/retR", (int) JITTER_SPECIALIZED_INSTRUCTION_WORD_NO); fflush (stderr);
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#undef JITTER_THIS_IS_A_REPLACEMENT
#define JITTER_THIS_IS_A_REPLACEMENT 1

    /* User code for !REPLACEMENT-pop-to-global/nR/fR/retR . */
  {
/* User-specified code, user code block part: beginning. */

    jitterlisp_object tagged_symbol = JITTER_ARGN0;
    struct jitterlisp_symbol *symbol = JITTERLISP_SYMBOL_DECODE(tagged_symbol);
#ifndef JITTERLISP_UNSAFE
    JITTER_BRANCH_FAST_IF_NONZERO (symbol->global_constant, JITTER_ARGF1);
#endif // #ifndef JITTERLISP_UNSAFE
    symbol->global_value = JITTER_TOP_MAINSTACK();
    JITTER_DROP_MAINSTACK();
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for !REPLACEMENT-pop-to-global/nR/fR/retR . */

  //fprintf (stderr, "..Executed replacement instruction %s\n", "!REPLACEMENT-pop-to-global/nR/fR/retR");
  //fprintf (stderr, "..Executed instruction %s\n", "!REPLACEMENT-pop-to-global/nR/fR/retR");
//#endif // #if 0
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
#ifdef JITTER_REPLICATE
  {
    /* Advance the instruction pointer, if any, to skip every
       residual but the last; branch back to replicated
       code. */
    const void *_jitter_back_to_replicated_code_pointer =
      JITTER_ARGP2;
    JITTER_SKIP_RESIDUALS_;
    goto * _jitter_back_to_replicated_code_pointer;
  }
#endif // #ifdef JITTER_REPLICATE

    /* Undefine the !REPLACEMENT-pop-to-global/nR/fR/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1
#   undef JITTER_SLOW_REGISTER_OFFSET2
#   undef JITTER_ARG2
#   undef JITTER_ARGN2
#   undef JITTER_ARGU2
#   undef JITTER_ARGP2
#   undef JITTER_ARGF2

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#ifndef JITTER_REPLICATE
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-pop-to-global/nR/fR/retR, _eREPLACEMENT_mpop_mto_mglobal__nR__fR__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#endif // #ifndef JITTER_REPLICATE
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for !REPLACEMENT-pop-to-global/nR/fR/retR, which started with its
       definitions. */
  }
#endif // #if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
/*  End of !REPLACEMENT-pop-to-global/nR/fR/retR , a replacement specialised instruction */

  /* Ordinary specialised instruction !REPLACEMENT-pop-to-global-defined/nR/fR/retR (replacement) */
  /* Omit this specialised instruction altogether unless
     replacements are in fact supported in this
     configuration. */
#if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
  JITTER_INSTRUCTION_PROLOG_(!REPLACEMENT-pop-to-global-defined/nR/fR/retR, _eREPLACEMENT_mpop_mto_mglobal_mdefined__nR__fR__retR, cold)
  { /* This block begins with definitions for !REPLACEMENT-pop-to-global-defined/nR/fR/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       291
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         !REPLACEMENT-pop-to-global-defined/nR/fR/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "pop-to-global-defined"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "!REPLACEMENT-pop-to-global-defined/nR/fR/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _eREPLACEMENT_mpop_mto_mglobal_mdefined__nR__fR__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is non-relocatable.
       Its 2-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST JITTER_BRANCH
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
    /* This specialized instruction is non-relocatable.
       Its 2-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 3

  /* Define argument-access macros for !REPLACEMENT-pop-to-global-defined/nR/fR/retR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a residual literal. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

    /* The 2th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG2  JITTER_RESIDUAL_ARGUMENT_2
    JITTER_MARK_RESIDUAL_2_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[2])
#else
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[3])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN2 (JITTER_ARG2.fixnum)
#   define JITTER_ARGU2 (JITTER_ARG2.ufixnum)
#   define JITTER_ARGP2 (JITTER_ARG2.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
    /* The 0th argument is a residual literal. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

    /* The 2th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG2  JITTER_RESIDUAL_ARGUMENT_2
    JITTER_MARK_RESIDUAL_2_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[2])
#else
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[3])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN2 (JITTER_ARG2.fixnum)
#   define JITTER_ARGU2 (JITTER_ARG2.ufixnum)
#   define JITTER_ARGP2 (JITTER_ARG2.pointer)
#   define JITTER_ARGF2 JITTER_ARGP2

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* When jumping to the non-relocatable part it is important not
   to use a fallback version of JITTER_COMPUTED_GOTO, in order to
   prevent GCC from tail-merging. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
    /* Jump to non-relocatable code. */
    JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);

    /* Here the residual arity is given as zero: it's too late to
       skip residuals, since we've already jumped and this code is
       unreachable.  The instruction pointer, if any, is advanced
       in the non-relocatable code. */
    JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-pop-to-global-defined/nR/fR/retR, _eREPLACEMENT_mpop_mto_mglobal_mdefined__nR__fR__retR, 0)

    /* Relocated code will jump to this label in non-relocated code. */
  JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
    JITTER_COMMENT_IN_ASM_("!REPLACEMENT-pop-to-global-defined/nR/fR/retR non-relocatable code");
#endif // #ifdef JITTER_REPLICATE
#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of !REPLACEMENT-pop-to-global-defined/nR/fR/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  no. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
//#if 0
  //fprintf (stderr, "Executing instruction %s..\n", "!REPLACEMENT-pop-to-global-defined/nR/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing replacement instruction %s..\n", "!REPLACEMENT-pop-to-global-defined/nR/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing non-relocatable instruction %s with JITTER_SPECIALIZED_INSTRUCTION_WORD_NO=%i..\n", "!REPLACEMENT-pop-to-global-defined/nR/fR/retR", (int) JITTER_SPECIALIZED_INSTRUCTION_WORD_NO); fflush (stderr);
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#undef JITTER_THIS_IS_A_REPLACEMENT
#define JITTER_THIS_IS_A_REPLACEMENT 1

    /* User code for !REPLACEMENT-pop-to-global-defined/nR/fR/retR . */
  {
/* User-specified code, user code block part: beginning. */

    jitterlisp_object tagged_symbol = JITTER_ARGN0;
    struct jitterlisp_symbol *symbol = JITTERLISP_SYMBOL_DECODE(tagged_symbol);
#ifndef JITTERLISP_UNSAFE
    JITTER_BRANCH_FAST_IF_NONZERO (symbol->global_constant, JITTER_ARGF1);
    JITTER_BRANCH_FAST_IF_EQUAL (symbol->global_value, JITTERLISP_UNDEFINED,
                                 JITTER_ARGF1);
#endif // #ifndef JITTERLISP_UNSAFE
    symbol->global_value = JITTER_TOP_MAINSTACK();
    JITTER_DROP_MAINSTACK();
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for !REPLACEMENT-pop-to-global-defined/nR/fR/retR . */

  //fprintf (stderr, "..Executed replacement instruction %s\n", "!REPLACEMENT-pop-to-global-defined/nR/fR/retR");
  //fprintf (stderr, "..Executed instruction %s\n", "!REPLACEMENT-pop-to-global-defined/nR/fR/retR");
//#endif // #if 0
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
#ifdef JITTER_REPLICATE
  {
    /* Advance the instruction pointer, if any, to skip every
       residual but the last; branch back to replicated
       code. */
    const void *_jitter_back_to_replicated_code_pointer =
      JITTER_ARGP2;
    JITTER_SKIP_RESIDUALS_;
    goto * _jitter_back_to_replicated_code_pointer;
  }
#endif // #ifdef JITTER_REPLICATE

    /* Undefine the !REPLACEMENT-pop-to-global-defined/nR/fR/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1
#   undef JITTER_SLOW_REGISTER_OFFSET2
#   undef JITTER_ARG2
#   undef JITTER_ARGN2
#   undef JITTER_ARGU2
#   undef JITTER_ARGP2
#   undef JITTER_ARGF2

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#ifndef JITTER_REPLICATE
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-pop-to-global-defined/nR/fR/retR, _eREPLACEMENT_mpop_mto_mglobal_mdefined__nR__fR__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#endif // #ifndef JITTER_REPLICATE
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for !REPLACEMENT-pop-to-global-defined/nR/fR/retR, which started with its
       definitions. */
  }
#endif // #if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
/*  End of !REPLACEMENT-pop-to-global-defined/nR/fR/retR , a replacement specialised instruction */

  /* Ordinary specialised instruction !REPLACEMENT-primitive/nR/n0/fR/retR (replacement) */
  /* Omit this specialised instruction altogether unless
     replacements are in fact supported in this
     configuration. */
#if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
  JITTER_INSTRUCTION_PROLOG_(!REPLACEMENT-primitive/nR/n0/fR/retR, _eREPLACEMENT_mprimitive__nR__n0__fR__retR, cold)
  { /* This block begins with definitions for !REPLACEMENT-primitive/nR/n0/fR/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       292
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         !REPLACEMENT-primitive/nR/n0/fR/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "primitive"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "!REPLACEMENT-primitive/nR/n0/fR/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _eREPLACEMENT_mprimitive__nR__n0__fR__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is non-relocatable.
       Its 3-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST JITTER_BRANCH
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
    /* This specialized instruction is non-relocatable.
       Its 3-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 3

  /* Define argument-access macros for !REPLACEMENT-primitive/nR/n0/fR/retR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a residual literal. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)

    /* The 1th argument is a nonresidual literal. */
#   define JITTER_ARG1  ((const union jitter_word){.fixnum = 0L})
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)

    /* The 2th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG2  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN2 (JITTER_ARG2.fixnum)
#   define JITTER_ARGU2 (JITTER_ARG2.ufixnum)
#   define JITTER_ARGP2 (JITTER_ARG2.pointer)
#   define JITTER_ARGF2 JITTER_ARGP2

    /* The 3th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG3  JITTER_RESIDUAL_ARGUMENT_2
    JITTER_MARK_RESIDUAL_2_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG3  (((union jitter_word*)jitter_ip)[2])
#else
#   define JITTER_ARG3  (((union jitter_word*)jitter_ip)[3])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN3 (JITTER_ARG3.fixnum)
#   define JITTER_ARGU3 (JITTER_ARG3.ufixnum)
#   define JITTER_ARGP3 (JITTER_ARG3.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
    /* The 0th argument is a residual literal. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a nonresidual literal. */
#   define JITTER_ARG1  ((const union jitter_word){.fixnum = 0L})
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

    /* The 2th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG2  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN2 (JITTER_ARG2.fixnum)
#   define JITTER_ARGU2 (JITTER_ARG2.ufixnum)
#   define JITTER_ARGP2 (JITTER_ARG2.pointer)
#   define JITTER_ARGF2 JITTER_ARGP2

    /* The 3th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG3  JITTER_RESIDUAL_ARGUMENT_2
    JITTER_MARK_RESIDUAL_2_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG3  (((union jitter_word*)jitter_ip)[2])
#else
#   define JITTER_ARG3  (((union jitter_word*)jitter_ip)[3])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN3 (JITTER_ARG3.fixnum)
#   define JITTER_ARGU3 (JITTER_ARG3.ufixnum)
#   define JITTER_ARGP3 (JITTER_ARG3.pointer)
#   define JITTER_ARGF3 JITTER_ARGP3

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* When jumping to the non-relocatable part it is important not
   to use a fallback version of JITTER_COMPUTED_GOTO, in order to
   prevent GCC from tail-merging. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
    /* Jump to non-relocatable code. */
    JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);

    /* Here the residual arity is given as zero: it's too late to
       skip residuals, since we've already jumped and this code is
       unreachable.  The instruction pointer, if any, is advanced
       in the non-relocatable code. */
    JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-primitive/nR/n0/fR/retR, _eREPLACEMENT_mprimitive__nR__n0__fR__retR, 0)

    /* Relocated code will jump to this label in non-relocated code. */
  JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
    JITTER_COMMENT_IN_ASM_("!REPLACEMENT-primitive/nR/n0/fR/retR non-relocatable code");
#endif // #ifdef JITTER_REPLICATE
#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of !REPLACEMENT-primitive/nR/n0/fR/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  no. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
//#if 0
  //fprintf (stderr, "Executing instruction %s..\n", "!REPLACEMENT-primitive/nR/n0/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing replacement instruction %s..\n", "!REPLACEMENT-primitive/nR/n0/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing non-relocatable instruction %s with JITTER_SPECIALIZED_INSTRUCTION_WORD_NO=%i..\n", "!REPLACEMENT-primitive/nR/n0/fR/retR", (int) JITTER_SPECIALIZED_INSTRUCTION_WORD_NO); fflush (stderr);
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#undef JITTER_THIS_IS_A_REPLACEMENT
#define JITTER_THIS_IS_A_REPLACEMENT 1

    /* User code for !REPLACEMENT-primitive/nR/n0/fR/retR . */
  {
/* User-specified code, user code block part: beginning. */

    /* The error-handling label is not actually used in this case: the
       primitive function, written in C, has its own handling.  It's
       harmless to have it anyway, as it makes the C code generator
       more uniform. */
    jitterlisp_primitive_function p
      = (jitterlisp_primitive_function) JITTER_ARGP0;
    const jitter_uint in_arity = JITTER_ARGN1;
    JITTER_PUSH_UNSPECIFIED_MAINSTACK();
    //asm volatile ("nop");
    jitterlisp_object *first_arg
      // FIXME: add a stack operator to compute this address.
      = (& JITTER_UNDER_TOP_MAINSTACK()) - in_arity + 1;
    jitterlisp_object res = JITTER_CALL_C (p, first_arg);

    jitter_uint i;
    // Remove as many elements as the primitive in-arity, but not more:
    // the top unspecified value we pushed will be replaced with the result.
    for (i = 0; i < in_arity; i ++)
      JITTER_NIP_MAINSTACK();
    //asm ("unop" : "+g" (jitter_state_runtime));
    JITTER_TOP_MAINSTACK() = res;
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for !REPLACEMENT-primitive/nR/n0/fR/retR . */

  //fprintf (stderr, "..Executed replacement instruction %s\n", "!REPLACEMENT-primitive/nR/n0/fR/retR");
  //fprintf (stderr, "..Executed instruction %s\n", "!REPLACEMENT-primitive/nR/n0/fR/retR");
//#endif // #if 0
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
#ifdef JITTER_REPLICATE
  {
    /* Advance the instruction pointer, if any, to skip every
       residual but the last; branch back to replicated
       code. */
    const void *_jitter_back_to_replicated_code_pointer =
      JITTER_ARGP3;
    JITTER_SKIP_RESIDUALS_;
    goto * _jitter_back_to_replicated_code_pointer;
  }
#endif // #ifdef JITTER_REPLICATE

    /* Undefine the !REPLACEMENT-primitive/nR/n0/fR/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1
#   undef JITTER_SLOW_REGISTER_OFFSET2
#   undef JITTER_ARG2
#   undef JITTER_ARGN2
#   undef JITTER_ARGU2
#   undef JITTER_ARGP2
#   undef JITTER_ARGF2
#   undef JITTER_SLOW_REGISTER_OFFSET3
#   undef JITTER_ARG3
#   undef JITTER_ARGN3
#   undef JITTER_ARGU3
#   undef JITTER_ARGP3
#   undef JITTER_ARGF3

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#ifndef JITTER_REPLICATE
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-primitive/nR/n0/fR/retR, _eREPLACEMENT_mprimitive__nR__n0__fR__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#endif // #ifndef JITTER_REPLICATE
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for !REPLACEMENT-primitive/nR/n0/fR/retR, which started with its
       definitions. */
  }
#endif // #if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
/*  End of !REPLACEMENT-primitive/nR/n0/fR/retR , a replacement specialised instruction */

  /* Ordinary specialised instruction !REPLACEMENT-primitive/nR/n1/fR/retR (replacement) */
  /* Omit this specialised instruction altogether unless
     replacements are in fact supported in this
     configuration. */
#if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
  JITTER_INSTRUCTION_PROLOG_(!REPLACEMENT-primitive/nR/n1/fR/retR, _eREPLACEMENT_mprimitive__nR__n1__fR__retR, cold)
  { /* This block begins with definitions for !REPLACEMENT-primitive/nR/n1/fR/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       293
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         !REPLACEMENT-primitive/nR/n1/fR/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "primitive"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "!REPLACEMENT-primitive/nR/n1/fR/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _eREPLACEMENT_mprimitive__nR__n1__fR__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is non-relocatable.
       Its 3-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST JITTER_BRANCH
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
    /* This specialized instruction is non-relocatable.
       Its 3-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 3

  /* Define argument-access macros for !REPLACEMENT-primitive/nR/n1/fR/retR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a residual literal. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)

    /* The 1th argument is a nonresidual literal. */
#   define JITTER_ARG1  ((const union jitter_word){.fixnum = 1L})
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)

    /* The 2th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG2  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN2 (JITTER_ARG2.fixnum)
#   define JITTER_ARGU2 (JITTER_ARG2.ufixnum)
#   define JITTER_ARGP2 (JITTER_ARG2.pointer)
#   define JITTER_ARGF2 JITTER_ARGP2

    /* The 3th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG3  JITTER_RESIDUAL_ARGUMENT_2
    JITTER_MARK_RESIDUAL_2_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG3  (((union jitter_word*)jitter_ip)[2])
#else
#   define JITTER_ARG3  (((union jitter_word*)jitter_ip)[3])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN3 (JITTER_ARG3.fixnum)
#   define JITTER_ARGU3 (JITTER_ARG3.ufixnum)
#   define JITTER_ARGP3 (JITTER_ARG3.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
    /* The 0th argument is a residual literal. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a nonresidual literal. */
#   define JITTER_ARG1  ((const union jitter_word){.fixnum = 1L})
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

    /* The 2th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG2  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN2 (JITTER_ARG2.fixnum)
#   define JITTER_ARGU2 (JITTER_ARG2.ufixnum)
#   define JITTER_ARGP2 (JITTER_ARG2.pointer)
#   define JITTER_ARGF2 JITTER_ARGP2

    /* The 3th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG3  JITTER_RESIDUAL_ARGUMENT_2
    JITTER_MARK_RESIDUAL_2_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG3  (((union jitter_word*)jitter_ip)[2])
#else
#   define JITTER_ARG3  (((union jitter_word*)jitter_ip)[3])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN3 (JITTER_ARG3.fixnum)
#   define JITTER_ARGU3 (JITTER_ARG3.ufixnum)
#   define JITTER_ARGP3 (JITTER_ARG3.pointer)
#   define JITTER_ARGF3 JITTER_ARGP3

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* When jumping to the non-relocatable part it is important not
   to use a fallback version of JITTER_COMPUTED_GOTO, in order to
   prevent GCC from tail-merging. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
    /* Jump to non-relocatable code. */
    JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);

    /* Here the residual arity is given as zero: it's too late to
       skip residuals, since we've already jumped and this code is
       unreachable.  The instruction pointer, if any, is advanced
       in the non-relocatable code. */
    JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-primitive/nR/n1/fR/retR, _eREPLACEMENT_mprimitive__nR__n1__fR__retR, 0)

    /* Relocated code will jump to this label in non-relocated code. */
  JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
    JITTER_COMMENT_IN_ASM_("!REPLACEMENT-primitive/nR/n1/fR/retR non-relocatable code");
#endif // #ifdef JITTER_REPLICATE
#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of !REPLACEMENT-primitive/nR/n1/fR/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  no. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
//#if 0
  //fprintf (stderr, "Executing instruction %s..\n", "!REPLACEMENT-primitive/nR/n1/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing replacement instruction %s..\n", "!REPLACEMENT-primitive/nR/n1/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing non-relocatable instruction %s with JITTER_SPECIALIZED_INSTRUCTION_WORD_NO=%i..\n", "!REPLACEMENT-primitive/nR/n1/fR/retR", (int) JITTER_SPECIALIZED_INSTRUCTION_WORD_NO); fflush (stderr);
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#undef JITTER_THIS_IS_A_REPLACEMENT
#define JITTER_THIS_IS_A_REPLACEMENT 1

    /* User code for !REPLACEMENT-primitive/nR/n1/fR/retR . */
  {
/* User-specified code, user code block part: beginning. */

    /* The error-handling label is not actually used in this case: the
       primitive function, written in C, has its own handling.  It's
       harmless to have it anyway, as it makes the C code generator
       more uniform. */
    jitterlisp_primitive_function p
      = (jitterlisp_primitive_function) JITTER_ARGP0;
    const jitter_uint in_arity = JITTER_ARGN1;
    JITTER_PUSH_UNSPECIFIED_MAINSTACK();
    //asm volatile ("nop");
    jitterlisp_object *first_arg
      // FIXME: add a stack operator to compute this address.
      = (& JITTER_UNDER_TOP_MAINSTACK()) - in_arity + 1;
    jitterlisp_object res = JITTER_CALL_C (p, first_arg);

    jitter_uint i;
    // Remove as many elements as the primitive in-arity, but not more:
    // the top unspecified value we pushed will be replaced with the result.
    for (i = 0; i < in_arity; i ++)
      JITTER_NIP_MAINSTACK();
    //asm ("unop" : "+g" (jitter_state_runtime));
    JITTER_TOP_MAINSTACK() = res;
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for !REPLACEMENT-primitive/nR/n1/fR/retR . */

  //fprintf (stderr, "..Executed replacement instruction %s\n", "!REPLACEMENT-primitive/nR/n1/fR/retR");
  //fprintf (stderr, "..Executed instruction %s\n", "!REPLACEMENT-primitive/nR/n1/fR/retR");
//#endif // #if 0
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
#ifdef JITTER_REPLICATE
  {
    /* Advance the instruction pointer, if any, to skip every
       residual but the last; branch back to replicated
       code. */
    const void *_jitter_back_to_replicated_code_pointer =
      JITTER_ARGP3;
    JITTER_SKIP_RESIDUALS_;
    goto * _jitter_back_to_replicated_code_pointer;
  }
#endif // #ifdef JITTER_REPLICATE

    /* Undefine the !REPLACEMENT-primitive/nR/n1/fR/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1
#   undef JITTER_SLOW_REGISTER_OFFSET2
#   undef JITTER_ARG2
#   undef JITTER_ARGN2
#   undef JITTER_ARGU2
#   undef JITTER_ARGP2
#   undef JITTER_ARGF2
#   undef JITTER_SLOW_REGISTER_OFFSET3
#   undef JITTER_ARG3
#   undef JITTER_ARGN3
#   undef JITTER_ARGU3
#   undef JITTER_ARGP3
#   undef JITTER_ARGF3

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#ifndef JITTER_REPLICATE
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-primitive/nR/n1/fR/retR, _eREPLACEMENT_mprimitive__nR__n1__fR__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#endif // #ifndef JITTER_REPLICATE
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for !REPLACEMENT-primitive/nR/n1/fR/retR, which started with its
       definitions. */
  }
#endif // #if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
/*  End of !REPLACEMENT-primitive/nR/n1/fR/retR , a replacement specialised instruction */

  /* Ordinary specialised instruction !REPLACEMENT-primitive/nR/n2/fR/retR (replacement) */
  /* Omit this specialised instruction altogether unless
     replacements are in fact supported in this
     configuration. */
#if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
  JITTER_INSTRUCTION_PROLOG_(!REPLACEMENT-primitive/nR/n2/fR/retR, _eREPLACEMENT_mprimitive__nR__n2__fR__retR, cold)
  { /* This block begins with definitions for !REPLACEMENT-primitive/nR/n2/fR/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       294
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         !REPLACEMENT-primitive/nR/n2/fR/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "primitive"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "!REPLACEMENT-primitive/nR/n2/fR/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _eREPLACEMENT_mprimitive__nR__n2__fR__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is non-relocatable.
       Its 3-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST JITTER_BRANCH
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
    /* This specialized instruction is non-relocatable.
       Its 3-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 3

  /* Define argument-access macros for !REPLACEMENT-primitive/nR/n2/fR/retR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a residual literal. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)

    /* The 1th argument is a nonresidual literal. */
#   define JITTER_ARG1  ((const union jitter_word){.fixnum = 2L})
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)

    /* The 2th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG2  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN2 (JITTER_ARG2.fixnum)
#   define JITTER_ARGU2 (JITTER_ARG2.ufixnum)
#   define JITTER_ARGP2 (JITTER_ARG2.pointer)
#   define JITTER_ARGF2 JITTER_ARGP2

    /* The 3th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG3  JITTER_RESIDUAL_ARGUMENT_2
    JITTER_MARK_RESIDUAL_2_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG3  (((union jitter_word*)jitter_ip)[2])
#else
#   define JITTER_ARG3  (((union jitter_word*)jitter_ip)[3])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN3 (JITTER_ARG3.fixnum)
#   define JITTER_ARGU3 (JITTER_ARG3.ufixnum)
#   define JITTER_ARGP3 (JITTER_ARG3.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
    /* The 0th argument is a residual literal. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a nonresidual literal. */
#   define JITTER_ARG1  ((const union jitter_word){.fixnum = 2L})
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

    /* The 2th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG2  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN2 (JITTER_ARG2.fixnum)
#   define JITTER_ARGU2 (JITTER_ARG2.ufixnum)
#   define JITTER_ARGP2 (JITTER_ARG2.pointer)
#   define JITTER_ARGF2 JITTER_ARGP2

    /* The 3th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG3  JITTER_RESIDUAL_ARGUMENT_2
    JITTER_MARK_RESIDUAL_2_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG3  (((union jitter_word*)jitter_ip)[2])
#else
#   define JITTER_ARG3  (((union jitter_word*)jitter_ip)[3])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN3 (JITTER_ARG3.fixnum)
#   define JITTER_ARGU3 (JITTER_ARG3.ufixnum)
#   define JITTER_ARGP3 (JITTER_ARG3.pointer)
#   define JITTER_ARGF3 JITTER_ARGP3

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* When jumping to the non-relocatable part it is important not
   to use a fallback version of JITTER_COMPUTED_GOTO, in order to
   prevent GCC from tail-merging. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
    /* Jump to non-relocatable code. */
    JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);

    /* Here the residual arity is given as zero: it's too late to
       skip residuals, since we've already jumped and this code is
       unreachable.  The instruction pointer, if any, is advanced
       in the non-relocatable code. */
    JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-primitive/nR/n2/fR/retR, _eREPLACEMENT_mprimitive__nR__n2__fR__retR, 0)

    /* Relocated code will jump to this label in non-relocated code. */
  JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
    JITTER_COMMENT_IN_ASM_("!REPLACEMENT-primitive/nR/n2/fR/retR non-relocatable code");
#endif // #ifdef JITTER_REPLICATE
#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of !REPLACEMENT-primitive/nR/n2/fR/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  no. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
//#if 0
  //fprintf (stderr, "Executing instruction %s..\n", "!REPLACEMENT-primitive/nR/n2/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing replacement instruction %s..\n", "!REPLACEMENT-primitive/nR/n2/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing non-relocatable instruction %s with JITTER_SPECIALIZED_INSTRUCTION_WORD_NO=%i..\n", "!REPLACEMENT-primitive/nR/n2/fR/retR", (int) JITTER_SPECIALIZED_INSTRUCTION_WORD_NO); fflush (stderr);
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#undef JITTER_THIS_IS_A_REPLACEMENT
#define JITTER_THIS_IS_A_REPLACEMENT 1

    /* User code for !REPLACEMENT-primitive/nR/n2/fR/retR . */
  {
/* User-specified code, user code block part: beginning. */

    /* The error-handling label is not actually used in this case: the
       primitive function, written in C, has its own handling.  It's
       harmless to have it anyway, as it makes the C code generator
       more uniform. */
    jitterlisp_primitive_function p
      = (jitterlisp_primitive_function) JITTER_ARGP0;
    const jitter_uint in_arity = JITTER_ARGN1;
    JITTER_PUSH_UNSPECIFIED_MAINSTACK();
    //asm volatile ("nop");
    jitterlisp_object *first_arg
      // FIXME: add a stack operator to compute this address.
      = (& JITTER_UNDER_TOP_MAINSTACK()) - in_arity + 1;
    jitterlisp_object res = JITTER_CALL_C (p, first_arg);

    jitter_uint i;
    // Remove as many elements as the primitive in-arity, but not more:
    // the top unspecified value we pushed will be replaced with the result.
    for (i = 0; i < in_arity; i ++)
      JITTER_NIP_MAINSTACK();
    //asm ("unop" : "+g" (jitter_state_runtime));
    JITTER_TOP_MAINSTACK() = res;
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for !REPLACEMENT-primitive/nR/n2/fR/retR . */

  //fprintf (stderr, "..Executed replacement instruction %s\n", "!REPLACEMENT-primitive/nR/n2/fR/retR");
  //fprintf (stderr, "..Executed instruction %s\n", "!REPLACEMENT-primitive/nR/n2/fR/retR");
//#endif // #if 0
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
#ifdef JITTER_REPLICATE
  {
    /* Advance the instruction pointer, if any, to skip every
       residual but the last; branch back to replicated
       code. */
    const void *_jitter_back_to_replicated_code_pointer =
      JITTER_ARGP3;
    JITTER_SKIP_RESIDUALS_;
    goto * _jitter_back_to_replicated_code_pointer;
  }
#endif // #ifdef JITTER_REPLICATE

    /* Undefine the !REPLACEMENT-primitive/nR/n2/fR/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1
#   undef JITTER_SLOW_REGISTER_OFFSET2
#   undef JITTER_ARG2
#   undef JITTER_ARGN2
#   undef JITTER_ARGU2
#   undef JITTER_ARGP2
#   undef JITTER_ARGF2
#   undef JITTER_SLOW_REGISTER_OFFSET3
#   undef JITTER_ARG3
#   undef JITTER_ARGN3
#   undef JITTER_ARGU3
#   undef JITTER_ARGP3
#   undef JITTER_ARGF3

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#ifndef JITTER_REPLICATE
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-primitive/nR/n2/fR/retR, _eREPLACEMENT_mprimitive__nR__n2__fR__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#endif // #ifndef JITTER_REPLICATE
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for !REPLACEMENT-primitive/nR/n2/fR/retR, which started with its
       definitions. */
  }
#endif // #if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
/*  End of !REPLACEMENT-primitive/nR/n2/fR/retR , a replacement specialised instruction */

  /* Ordinary specialised instruction !REPLACEMENT-primitive/nR/n3/fR/retR (replacement) */
  /* Omit this specialised instruction altogether unless
     replacements are in fact supported in this
     configuration. */
#if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
  JITTER_INSTRUCTION_PROLOG_(!REPLACEMENT-primitive/nR/n3/fR/retR, _eREPLACEMENT_mprimitive__nR__n3__fR__retR, cold)
  { /* This block begins with definitions for !REPLACEMENT-primitive/nR/n3/fR/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       295
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         !REPLACEMENT-primitive/nR/n3/fR/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "primitive"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "!REPLACEMENT-primitive/nR/n3/fR/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _eREPLACEMENT_mprimitive__nR__n3__fR__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is non-relocatable.
       Its 3-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST JITTER_BRANCH
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
    /* This specialized instruction is non-relocatable.
       Its 3-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 3

  /* Define argument-access macros for !REPLACEMENT-primitive/nR/n3/fR/retR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a residual literal. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)

    /* The 1th argument is a nonresidual literal. */
#   define JITTER_ARG1  ((const union jitter_word){.fixnum = 3L})
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)

    /* The 2th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG2  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN2 (JITTER_ARG2.fixnum)
#   define JITTER_ARGU2 (JITTER_ARG2.ufixnum)
#   define JITTER_ARGP2 (JITTER_ARG2.pointer)
#   define JITTER_ARGF2 JITTER_ARGP2

    /* The 3th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG3  JITTER_RESIDUAL_ARGUMENT_2
    JITTER_MARK_RESIDUAL_2_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG3  (((union jitter_word*)jitter_ip)[2])
#else
#   define JITTER_ARG3  (((union jitter_word*)jitter_ip)[3])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN3 (JITTER_ARG3.fixnum)
#   define JITTER_ARGU3 (JITTER_ARG3.ufixnum)
#   define JITTER_ARGP3 (JITTER_ARG3.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
    /* The 0th argument is a residual literal. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a nonresidual literal. */
#   define JITTER_ARG1  ((const union jitter_word){.fixnum = 3L})
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

    /* The 2th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG2  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN2 (JITTER_ARG2.fixnum)
#   define JITTER_ARGU2 (JITTER_ARG2.ufixnum)
#   define JITTER_ARGP2 (JITTER_ARG2.pointer)
#   define JITTER_ARGF2 JITTER_ARGP2

    /* The 3th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG3  JITTER_RESIDUAL_ARGUMENT_2
    JITTER_MARK_RESIDUAL_2_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG3  (((union jitter_word*)jitter_ip)[2])
#else
#   define JITTER_ARG3  (((union jitter_word*)jitter_ip)[3])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN3 (JITTER_ARG3.fixnum)
#   define JITTER_ARGU3 (JITTER_ARG3.ufixnum)
#   define JITTER_ARGP3 (JITTER_ARG3.pointer)
#   define JITTER_ARGF3 JITTER_ARGP3

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* When jumping to the non-relocatable part it is important not
   to use a fallback version of JITTER_COMPUTED_GOTO, in order to
   prevent GCC from tail-merging. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
    /* Jump to non-relocatable code. */
    JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);

    /* Here the residual arity is given as zero: it's too late to
       skip residuals, since we've already jumped and this code is
       unreachable.  The instruction pointer, if any, is advanced
       in the non-relocatable code. */
    JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-primitive/nR/n3/fR/retR, _eREPLACEMENT_mprimitive__nR__n3__fR__retR, 0)

    /* Relocated code will jump to this label in non-relocated code. */
  JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
    JITTER_COMMENT_IN_ASM_("!REPLACEMENT-primitive/nR/n3/fR/retR non-relocatable code");
#endif // #ifdef JITTER_REPLICATE
#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of !REPLACEMENT-primitive/nR/n3/fR/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  no. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
//#if 0
  //fprintf (stderr, "Executing instruction %s..\n", "!REPLACEMENT-primitive/nR/n3/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing replacement instruction %s..\n", "!REPLACEMENT-primitive/nR/n3/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing non-relocatable instruction %s with JITTER_SPECIALIZED_INSTRUCTION_WORD_NO=%i..\n", "!REPLACEMENT-primitive/nR/n3/fR/retR", (int) JITTER_SPECIALIZED_INSTRUCTION_WORD_NO); fflush (stderr);
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#undef JITTER_THIS_IS_A_REPLACEMENT
#define JITTER_THIS_IS_A_REPLACEMENT 1

    /* User code for !REPLACEMENT-primitive/nR/n3/fR/retR . */
  {
/* User-specified code, user code block part: beginning. */

    /* The error-handling label is not actually used in this case: the
       primitive function, written in C, has its own handling.  It's
       harmless to have it anyway, as it makes the C code generator
       more uniform. */
    jitterlisp_primitive_function p
      = (jitterlisp_primitive_function) JITTER_ARGP0;
    const jitter_uint in_arity = JITTER_ARGN1;
    JITTER_PUSH_UNSPECIFIED_MAINSTACK();
    //asm volatile ("nop");
    jitterlisp_object *first_arg
      // FIXME: add a stack operator to compute this address.
      = (& JITTER_UNDER_TOP_MAINSTACK()) - in_arity + 1;
    jitterlisp_object res = JITTER_CALL_C (p, first_arg);

    jitter_uint i;
    // Remove as many elements as the primitive in-arity, but not more:
    // the top unspecified value we pushed will be replaced with the result.
    for (i = 0; i < in_arity; i ++)
      JITTER_NIP_MAINSTACK();
    //asm ("unop" : "+g" (jitter_state_runtime));
    JITTER_TOP_MAINSTACK() = res;
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for !REPLACEMENT-primitive/nR/n3/fR/retR . */

  //fprintf (stderr, "..Executed replacement instruction %s\n", "!REPLACEMENT-primitive/nR/n3/fR/retR");
  //fprintf (stderr, "..Executed instruction %s\n", "!REPLACEMENT-primitive/nR/n3/fR/retR");
//#endif // #if 0
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
#ifdef JITTER_REPLICATE
  {
    /* Advance the instruction pointer, if any, to skip every
       residual but the last; branch back to replicated
       code. */
    const void *_jitter_back_to_replicated_code_pointer =
      JITTER_ARGP3;
    JITTER_SKIP_RESIDUALS_;
    goto * _jitter_back_to_replicated_code_pointer;
  }
#endif // #ifdef JITTER_REPLICATE

    /* Undefine the !REPLACEMENT-primitive/nR/n3/fR/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1
#   undef JITTER_SLOW_REGISTER_OFFSET2
#   undef JITTER_ARG2
#   undef JITTER_ARGN2
#   undef JITTER_ARGU2
#   undef JITTER_ARGP2
#   undef JITTER_ARGF2
#   undef JITTER_SLOW_REGISTER_OFFSET3
#   undef JITTER_ARG3
#   undef JITTER_ARGN3
#   undef JITTER_ARGU3
#   undef JITTER_ARGP3
#   undef JITTER_ARGF3

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#ifndef JITTER_REPLICATE
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-primitive/nR/n3/fR/retR, _eREPLACEMENT_mprimitive__nR__n3__fR__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#endif // #ifndef JITTER_REPLICATE
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for !REPLACEMENT-primitive/nR/n3/fR/retR, which started with its
       definitions. */
  }
#endif // #if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
/*  End of !REPLACEMENT-primitive/nR/n3/fR/retR , a replacement specialised instruction */

  /* Ordinary specialised instruction !REPLACEMENT-primitive/nR/n4/fR/retR (replacement) */
  /* Omit this specialised instruction altogether unless
     replacements are in fact supported in this
     configuration. */
#if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
  JITTER_INSTRUCTION_PROLOG_(!REPLACEMENT-primitive/nR/n4/fR/retR, _eREPLACEMENT_mprimitive__nR__n4__fR__retR, cold)
  { /* This block begins with definitions for !REPLACEMENT-primitive/nR/n4/fR/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       296
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         !REPLACEMENT-primitive/nR/n4/fR/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "primitive"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "!REPLACEMENT-primitive/nR/n4/fR/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _eREPLACEMENT_mprimitive__nR__n4__fR__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is non-relocatable.
       Its 3-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST JITTER_BRANCH
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
    /* This specialized instruction is non-relocatable.
       Its 3-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 3

  /* Define argument-access macros for !REPLACEMENT-primitive/nR/n4/fR/retR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a residual literal. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)

    /* The 1th argument is a nonresidual literal. */
#   define JITTER_ARG1  ((const union jitter_word){.fixnum = 4L})
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)

    /* The 2th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG2  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN2 (JITTER_ARG2.fixnum)
#   define JITTER_ARGU2 (JITTER_ARG2.ufixnum)
#   define JITTER_ARGP2 (JITTER_ARG2.pointer)
#   define JITTER_ARGF2 JITTER_ARGP2

    /* The 3th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG3  JITTER_RESIDUAL_ARGUMENT_2
    JITTER_MARK_RESIDUAL_2_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG3  (((union jitter_word*)jitter_ip)[2])
#else
#   define JITTER_ARG3  (((union jitter_word*)jitter_ip)[3])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN3 (JITTER_ARG3.fixnum)
#   define JITTER_ARGU3 (JITTER_ARG3.ufixnum)
#   define JITTER_ARGP3 (JITTER_ARG3.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
    /* The 0th argument is a residual literal. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a nonresidual literal. */
#   define JITTER_ARG1  ((const union jitter_word){.fixnum = 4L})
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

    /* The 2th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG2  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN2 (JITTER_ARG2.fixnum)
#   define JITTER_ARGU2 (JITTER_ARG2.ufixnum)
#   define JITTER_ARGP2 (JITTER_ARG2.pointer)
#   define JITTER_ARGF2 JITTER_ARGP2

    /* The 3th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG3  JITTER_RESIDUAL_ARGUMENT_2
    JITTER_MARK_RESIDUAL_2_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG3  (((union jitter_word*)jitter_ip)[2])
#else
#   define JITTER_ARG3  (((union jitter_word*)jitter_ip)[3])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN3 (JITTER_ARG3.fixnum)
#   define JITTER_ARGU3 (JITTER_ARG3.ufixnum)
#   define JITTER_ARGP3 (JITTER_ARG3.pointer)
#   define JITTER_ARGF3 JITTER_ARGP3

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* When jumping to the non-relocatable part it is important not
   to use a fallback version of JITTER_COMPUTED_GOTO, in order to
   prevent GCC from tail-merging. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
    /* Jump to non-relocatable code. */
    JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);

    /* Here the residual arity is given as zero: it's too late to
       skip residuals, since we've already jumped and this code is
       unreachable.  The instruction pointer, if any, is advanced
       in the non-relocatable code. */
    JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-primitive/nR/n4/fR/retR, _eREPLACEMENT_mprimitive__nR__n4__fR__retR, 0)

    /* Relocated code will jump to this label in non-relocated code. */
  JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
    JITTER_COMMENT_IN_ASM_("!REPLACEMENT-primitive/nR/n4/fR/retR non-relocatable code");
#endif // #ifdef JITTER_REPLICATE
#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of !REPLACEMENT-primitive/nR/n4/fR/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  no. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
//#if 0
  //fprintf (stderr, "Executing instruction %s..\n", "!REPLACEMENT-primitive/nR/n4/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing replacement instruction %s..\n", "!REPLACEMENT-primitive/nR/n4/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing non-relocatable instruction %s with JITTER_SPECIALIZED_INSTRUCTION_WORD_NO=%i..\n", "!REPLACEMENT-primitive/nR/n4/fR/retR", (int) JITTER_SPECIALIZED_INSTRUCTION_WORD_NO); fflush (stderr);
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#undef JITTER_THIS_IS_A_REPLACEMENT
#define JITTER_THIS_IS_A_REPLACEMENT 1

    /* User code for !REPLACEMENT-primitive/nR/n4/fR/retR . */
  {
/* User-specified code, user code block part: beginning. */

    /* The error-handling label is not actually used in this case: the
       primitive function, written in C, has its own handling.  It's
       harmless to have it anyway, as it makes the C code generator
       more uniform. */
    jitterlisp_primitive_function p
      = (jitterlisp_primitive_function) JITTER_ARGP0;
    const jitter_uint in_arity = JITTER_ARGN1;
    JITTER_PUSH_UNSPECIFIED_MAINSTACK();
    //asm volatile ("nop");
    jitterlisp_object *first_arg
      // FIXME: add a stack operator to compute this address.
      = (& JITTER_UNDER_TOP_MAINSTACK()) - in_arity + 1;
    jitterlisp_object res = JITTER_CALL_C (p, first_arg);

    jitter_uint i;
    // Remove as many elements as the primitive in-arity, but not more:
    // the top unspecified value we pushed will be replaced with the result.
    for (i = 0; i < in_arity; i ++)
      JITTER_NIP_MAINSTACK();
    //asm ("unop" : "+g" (jitter_state_runtime));
    JITTER_TOP_MAINSTACK() = res;
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for !REPLACEMENT-primitive/nR/n4/fR/retR . */

  //fprintf (stderr, "..Executed replacement instruction %s\n", "!REPLACEMENT-primitive/nR/n4/fR/retR");
  //fprintf (stderr, "..Executed instruction %s\n", "!REPLACEMENT-primitive/nR/n4/fR/retR");
//#endif // #if 0
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
#ifdef JITTER_REPLICATE
  {
    /* Advance the instruction pointer, if any, to skip every
       residual but the last; branch back to replicated
       code. */
    const void *_jitter_back_to_replicated_code_pointer =
      JITTER_ARGP3;
    JITTER_SKIP_RESIDUALS_;
    goto * _jitter_back_to_replicated_code_pointer;
  }
#endif // #ifdef JITTER_REPLICATE

    /* Undefine the !REPLACEMENT-primitive/nR/n4/fR/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1
#   undef JITTER_SLOW_REGISTER_OFFSET2
#   undef JITTER_ARG2
#   undef JITTER_ARGN2
#   undef JITTER_ARGU2
#   undef JITTER_ARGP2
#   undef JITTER_ARGF2
#   undef JITTER_SLOW_REGISTER_OFFSET3
#   undef JITTER_ARG3
#   undef JITTER_ARGN3
#   undef JITTER_ARGU3
#   undef JITTER_ARGP3
#   undef JITTER_ARGF3

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#ifndef JITTER_REPLICATE
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-primitive/nR/n4/fR/retR, _eREPLACEMENT_mprimitive__nR__n4__fR__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#endif // #ifndef JITTER_REPLICATE
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for !REPLACEMENT-primitive/nR/n4/fR/retR, which started with its
       definitions. */
  }
#endif // #if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
/*  End of !REPLACEMENT-primitive/nR/n4/fR/retR , a replacement specialised instruction */

  /* Ordinary specialised instruction !REPLACEMENT-primitive/nR/nR/fR/retR (replacement) */
  /* Omit this specialised instruction altogether unless
     replacements are in fact supported in this
     configuration. */
#if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
  JITTER_INSTRUCTION_PROLOG_(!REPLACEMENT-primitive/nR/nR/fR/retR, _eREPLACEMENT_mprimitive__nR__nR__fR__retR, cold)
  { /* This block begins with definitions for !REPLACEMENT-primitive/nR/nR/fR/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       297
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         !REPLACEMENT-primitive/nR/nR/fR/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "primitive"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "!REPLACEMENT-primitive/nR/nR/fR/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _eREPLACEMENT_mprimitive__nR__nR__fR__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is non-relocatable.
       Its 3-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST JITTER_BRANCH
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
    /* This specialized instruction is non-relocatable.
       Its 3-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 4

  /* Define argument-access macros for !REPLACEMENT-primitive/nR/nR/fR/retR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a residual literal. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)

    /* The 1th argument is a residual literal. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)

    /* The 2th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG2  JITTER_RESIDUAL_ARGUMENT_2
    JITTER_MARK_RESIDUAL_2_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[2])
#else
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[3])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN2 (JITTER_ARG2.fixnum)
#   define JITTER_ARGU2 (JITTER_ARG2.ufixnum)
#   define JITTER_ARGP2 (JITTER_ARG2.pointer)
#   define JITTER_ARGF2 JITTER_ARGP2

    /* The 3th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG3  JITTER_RESIDUAL_ARGUMENT_3
    JITTER_MARK_RESIDUAL_3_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG3  (((union jitter_word*)jitter_ip)[3])
#else
#   define JITTER_ARG3  (((union jitter_word*)jitter_ip)[4])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN3 (JITTER_ARG3.fixnum)
#   define JITTER_ARGU3 (JITTER_ARG3.ufixnum)
#   define JITTER_ARGP3 (JITTER_ARG3.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
    /* The 0th argument is a residual literal. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual literal. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

    /* The 2th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG2  JITTER_RESIDUAL_ARGUMENT_2
    JITTER_MARK_RESIDUAL_2_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[2])
#else
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[3])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN2 (JITTER_ARG2.fixnum)
#   define JITTER_ARGU2 (JITTER_ARG2.ufixnum)
#   define JITTER_ARGP2 (JITTER_ARG2.pointer)
#   define JITTER_ARGF2 JITTER_ARGP2

    /* The 3th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG3  JITTER_RESIDUAL_ARGUMENT_3
    JITTER_MARK_RESIDUAL_3_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG3  (((union jitter_word*)jitter_ip)[3])
#else
#   define JITTER_ARG3  (((union jitter_word*)jitter_ip)[4])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN3 (JITTER_ARG3.fixnum)
#   define JITTER_ARGU3 (JITTER_ARG3.ufixnum)
#   define JITTER_ARGP3 (JITTER_ARG3.pointer)
#   define JITTER_ARGF3 JITTER_ARGP3

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* When jumping to the non-relocatable part it is important not
   to use a fallback version of JITTER_COMPUTED_GOTO, in order to
   prevent GCC from tail-merging. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
    /* Jump to non-relocatable code. */
    JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);

    /* Here the residual arity is given as zero: it's too late to
       skip residuals, since we've already jumped and this code is
       unreachable.  The instruction pointer, if any, is advanced
       in the non-relocatable code. */
    JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-primitive/nR/nR/fR/retR, _eREPLACEMENT_mprimitive__nR__nR__fR__retR, 0)

    /* Relocated code will jump to this label in non-relocated code. */
  JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
    JITTER_COMMENT_IN_ASM_("!REPLACEMENT-primitive/nR/nR/fR/retR non-relocatable code");
#endif // #ifdef JITTER_REPLICATE
#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of !REPLACEMENT-primitive/nR/nR/fR/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  no. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
//#if 0
  //fprintf (stderr, "Executing instruction %s..\n", "!REPLACEMENT-primitive/nR/nR/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing replacement instruction %s..\n", "!REPLACEMENT-primitive/nR/nR/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing non-relocatable instruction %s with JITTER_SPECIALIZED_INSTRUCTION_WORD_NO=%i..\n", "!REPLACEMENT-primitive/nR/nR/fR/retR", (int) JITTER_SPECIALIZED_INSTRUCTION_WORD_NO); fflush (stderr);
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#undef JITTER_THIS_IS_A_REPLACEMENT
#define JITTER_THIS_IS_A_REPLACEMENT 1

    /* User code for !REPLACEMENT-primitive/nR/nR/fR/retR . */
  {
/* User-specified code, user code block part: beginning. */

    /* The error-handling label is not actually used in this case: the
       primitive function, written in C, has its own handling.  It's
       harmless to have it anyway, as it makes the C code generator
       more uniform. */
    jitterlisp_primitive_function p
      = (jitterlisp_primitive_function) JITTER_ARGP0;
    const jitter_uint in_arity = JITTER_ARGN1;
    JITTER_PUSH_UNSPECIFIED_MAINSTACK();
    //asm volatile ("nop");
    jitterlisp_object *first_arg
      // FIXME: add a stack operator to compute this address.
      = (& JITTER_UNDER_TOP_MAINSTACK()) - in_arity + 1;
    jitterlisp_object res = JITTER_CALL_C (p, first_arg);

    jitter_uint i;
    // Remove as many elements as the primitive in-arity, but not more:
    // the top unspecified value we pushed will be replaced with the result.
    for (i = 0; i < in_arity; i ++)
      JITTER_NIP_MAINSTACK();
    //asm ("unop" : "+g" (jitter_state_runtime));
    JITTER_TOP_MAINSTACK() = res;
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for !REPLACEMENT-primitive/nR/nR/fR/retR . */

  //fprintf (stderr, "..Executed replacement instruction %s\n", "!REPLACEMENT-primitive/nR/nR/fR/retR");
  //fprintf (stderr, "..Executed instruction %s\n", "!REPLACEMENT-primitive/nR/nR/fR/retR");
//#endif // #if 0
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
#ifdef JITTER_REPLICATE
  {
    /* Advance the instruction pointer, if any, to skip every
       residual but the last; branch back to replicated
       code. */
    const void *_jitter_back_to_replicated_code_pointer =
      JITTER_ARGP3;
    JITTER_SKIP_RESIDUALS_;
    goto * _jitter_back_to_replicated_code_pointer;
  }
#endif // #ifdef JITTER_REPLICATE

    /* Undefine the !REPLACEMENT-primitive/nR/nR/fR/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1
#   undef JITTER_SLOW_REGISTER_OFFSET2
#   undef JITTER_ARG2
#   undef JITTER_ARGN2
#   undef JITTER_ARGU2
#   undef JITTER_ARGP2
#   undef JITTER_ARGF2
#   undef JITTER_SLOW_REGISTER_OFFSET3
#   undef JITTER_ARG3
#   undef JITTER_ARGN3
#   undef JITTER_ARGU3
#   undef JITTER_ARGP3
#   undef JITTER_ARGF3

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#ifndef JITTER_REPLICATE
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-primitive/nR/nR/fR/retR, _eREPLACEMENT_mprimitive__nR__nR__fR__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#endif // #ifndef JITTER_REPLICATE
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for !REPLACEMENT-primitive/nR/nR/fR/retR, which started with its
       definitions. */
  }
#endif // #if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
/*  End of !REPLACEMENT-primitive/nR/nR/fR/retR , a replacement specialised instruction */

  /* Ordinary specialised instruction !REPLACEMENT-primitive-box-get/fR/retR (replacement) */
  /* Omit this specialised instruction altogether unless
     replacements are in fact supported in this
     configuration. */
#if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
  JITTER_INSTRUCTION_PROLOG_(!REPLACEMENT-primitive-box-get/fR/retR, _eREPLACEMENT_mprimitive_mbox_mget__fR__retR, cold)
  { /* This block begins with definitions for !REPLACEMENT-primitive-box-get/fR/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       298
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         !REPLACEMENT-primitive-box-get/fR/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "primitive-box-get"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "!REPLACEMENT-primitive-box-get/fR/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _eREPLACEMENT_mprimitive_mbox_mget__fR__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST JITTER_BRANCH
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 2

  /* Define argument-access macros for !REPLACEMENT-primitive-box-get/fR/retR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
    /* The 0th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* When jumping to the non-relocatable part it is important not
   to use a fallback version of JITTER_COMPUTED_GOTO, in order to
   prevent GCC from tail-merging. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
    /* Jump to non-relocatable code. */
    JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);

    /* Here the residual arity is given as zero: it's too late to
       skip residuals, since we've already jumped and this code is
       unreachable.  The instruction pointer, if any, is advanced
       in the non-relocatable code. */
    JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-primitive-box-get/fR/retR, _eREPLACEMENT_mprimitive_mbox_mget__fR__retR, 0)

    /* Relocated code will jump to this label in non-relocated code. */
  JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
    JITTER_COMMENT_IN_ASM_("!REPLACEMENT-primitive-box-get/fR/retR non-relocatable code");
#endif // #ifdef JITTER_REPLICATE
#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of !REPLACEMENT-primitive-box-get/fR/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  no. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
//#if 0
  //fprintf (stderr, "Executing instruction %s..\n", "!REPLACEMENT-primitive-box-get/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing replacement instruction %s..\n", "!REPLACEMENT-primitive-box-get/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing non-relocatable instruction %s with JITTER_SPECIALIZED_INSTRUCTION_WORD_NO=%i..\n", "!REPLACEMENT-primitive-box-get/fR/retR", (int) JITTER_SPECIALIZED_INSTRUCTION_WORD_NO); fflush (stderr);
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#undef JITTER_THIS_IS_A_REPLACEMENT
#define JITTER_THIS_IS_A_REPLACEMENT 1

    /* User code for !REPLACEMENT-primitive-box-get/fR/retR . */
  {
/* User-specified code, user code block part: beginning. */

    JITTERLISPVM_CHECK_TYPES_1(BOX, JITTER_ARGF0);
    JITTERLISP_BOX_GET_(JITTER_TOP_MAINSTACK(), JITTER_TOP_MAINSTACK());
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for !REPLACEMENT-primitive-box-get/fR/retR . */

  //fprintf (stderr, "..Executed replacement instruction %s\n", "!REPLACEMENT-primitive-box-get/fR/retR");
  //fprintf (stderr, "..Executed instruction %s\n", "!REPLACEMENT-primitive-box-get/fR/retR");
//#endif // #if 0
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
#ifdef JITTER_REPLICATE
  {
    /* Advance the instruction pointer, if any, to skip every
       residual but the last; branch back to replicated
       code. */
    const void *_jitter_back_to_replicated_code_pointer =
      JITTER_ARGP1;
    JITTER_SKIP_RESIDUALS_;
    goto * _jitter_back_to_replicated_code_pointer;
  }
#endif // #ifdef JITTER_REPLICATE

    /* Undefine the !REPLACEMENT-primitive-box-get/fR/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#ifndef JITTER_REPLICATE
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-primitive-box-get/fR/retR, _eREPLACEMENT_mprimitive_mbox_mget__fR__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#endif // #ifndef JITTER_REPLICATE
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for !REPLACEMENT-primitive-box-get/fR/retR, which started with its
       definitions. */
  }
#endif // #if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
/*  End of !REPLACEMENT-primitive-box-get/fR/retR , a replacement specialised instruction */

  /* Ordinary specialised instruction !REPLACEMENT-primitive-box-setb-special/fR/retR (replacement) */
  /* Omit this specialised instruction altogether unless
     replacements are in fact supported in this
     configuration. */
#if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
  JITTER_INSTRUCTION_PROLOG_(!REPLACEMENT-primitive-box-setb-special/fR/retR, _eREPLACEMENT_mprimitive_mbox_msetb_mspecial__fR__retR, cold)
  { /* This block begins with definitions for !REPLACEMENT-primitive-box-setb-special/fR/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       299
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         !REPLACEMENT-primitive-box-setb-special/fR/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "primitive-box-setb-special"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "!REPLACEMENT-primitive-box-setb-special/fR/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _eREPLACEMENT_mprimitive_mbox_msetb_mspecial__fR__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST JITTER_BRANCH
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 2

  /* Define argument-access macros for !REPLACEMENT-primitive-box-setb-special/fR/retR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
    /* The 0th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* When jumping to the non-relocatable part it is important not
   to use a fallback version of JITTER_COMPUTED_GOTO, in order to
   prevent GCC from tail-merging. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
    /* Jump to non-relocatable code. */
    JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);

    /* Here the residual arity is given as zero: it's too late to
       skip residuals, since we've already jumped and this code is
       unreachable.  The instruction pointer, if any, is advanced
       in the non-relocatable code. */
    JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-primitive-box-setb-special/fR/retR, _eREPLACEMENT_mprimitive_mbox_msetb_mspecial__fR__retR, 0)

    /* Relocated code will jump to this label in non-relocated code. */
  JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
    JITTER_COMMENT_IN_ASM_("!REPLACEMENT-primitive-box-setb-special/fR/retR non-relocatable code");
#endif // #ifdef JITTER_REPLICATE
#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of !REPLACEMENT-primitive-box-setb-special/fR/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  no. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
//#if 0
  //fprintf (stderr, "Executing instruction %s..\n", "!REPLACEMENT-primitive-box-setb-special/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing replacement instruction %s..\n", "!REPLACEMENT-primitive-box-setb-special/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing non-relocatable instruction %s with JITTER_SPECIALIZED_INSTRUCTION_WORD_NO=%i..\n", "!REPLACEMENT-primitive-box-setb-special/fR/retR", (int) JITTER_SPECIALIZED_INSTRUCTION_WORD_NO); fflush (stderr);
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#undef JITTER_THIS_IS_A_REPLACEMENT
#define JITTER_THIS_IS_A_REPLACEMENT 1

    /* User code for !REPLACEMENT-primitive-box-setb-special/fR/retR . */
  {
/* User-specified code, user code block part: beginning. */

    JITTERLISPVM_CHECK_TYPES_2(BOX, ANYTHING, JITTER_ARGF0);
    jitterlisp_object useless __attribute__ ((unused));
    JITTERLISP_BOX_SETB_(useless,
                         JITTER_UNDER_TOP_MAINSTACK(), JITTER_TOP_MAINSTACK());
    /* Leave the two operands on the stack. */
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for !REPLACEMENT-primitive-box-setb-special/fR/retR . */

  //fprintf (stderr, "..Executed replacement instruction %s\n", "!REPLACEMENT-primitive-box-setb-special/fR/retR");
  //fprintf (stderr, "..Executed instruction %s\n", "!REPLACEMENT-primitive-box-setb-special/fR/retR");
//#endif // #if 0
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
#ifdef JITTER_REPLICATE
  {
    /* Advance the instruction pointer, if any, to skip every
       residual but the last; branch back to replicated
       code. */
    const void *_jitter_back_to_replicated_code_pointer =
      JITTER_ARGP1;
    JITTER_SKIP_RESIDUALS_;
    goto * _jitter_back_to_replicated_code_pointer;
  }
#endif // #ifdef JITTER_REPLICATE

    /* Undefine the !REPLACEMENT-primitive-box-setb-special/fR/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#ifndef JITTER_REPLICATE
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-primitive-box-setb-special/fR/retR, _eREPLACEMENT_mprimitive_mbox_msetb_mspecial__fR__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#endif // #ifndef JITTER_REPLICATE
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for !REPLACEMENT-primitive-box-setb-special/fR/retR, which started with its
       definitions. */
  }
#endif // #if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
/*  End of !REPLACEMENT-primitive-box-setb-special/fR/retR , a replacement specialised instruction */

  /* Ordinary specialised instruction !REPLACEMENT-primitive-car/fR/retR (replacement) */
  /* Omit this specialised instruction altogether unless
     replacements are in fact supported in this
     configuration. */
#if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
  JITTER_INSTRUCTION_PROLOG_(!REPLACEMENT-primitive-car/fR/retR, _eREPLACEMENT_mprimitive_mcar__fR__retR, cold)
  { /* This block begins with definitions for !REPLACEMENT-primitive-car/fR/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       300
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         !REPLACEMENT-primitive-car/fR/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "primitive-car"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "!REPLACEMENT-primitive-car/fR/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _eREPLACEMENT_mprimitive_mcar__fR__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST JITTER_BRANCH
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 2

  /* Define argument-access macros for !REPLACEMENT-primitive-car/fR/retR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
    /* The 0th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* When jumping to the non-relocatable part it is important not
   to use a fallback version of JITTER_COMPUTED_GOTO, in order to
   prevent GCC from tail-merging. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
    /* Jump to non-relocatable code. */
    JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);

    /* Here the residual arity is given as zero: it's too late to
       skip residuals, since we've already jumped and this code is
       unreachable.  The instruction pointer, if any, is advanced
       in the non-relocatable code. */
    JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-primitive-car/fR/retR, _eREPLACEMENT_mprimitive_mcar__fR__retR, 0)

    /* Relocated code will jump to this label in non-relocated code. */
  JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
    JITTER_COMMENT_IN_ASM_("!REPLACEMENT-primitive-car/fR/retR non-relocatable code");
#endif // #ifdef JITTER_REPLICATE
#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of !REPLACEMENT-primitive-car/fR/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  no. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
//#if 0
  //fprintf (stderr, "Executing instruction %s..\n", "!REPLACEMENT-primitive-car/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing replacement instruction %s..\n", "!REPLACEMENT-primitive-car/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing non-relocatable instruction %s with JITTER_SPECIALIZED_INSTRUCTION_WORD_NO=%i..\n", "!REPLACEMENT-primitive-car/fR/retR", (int) JITTER_SPECIALIZED_INSTRUCTION_WORD_NO); fflush (stderr);
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#undef JITTER_THIS_IS_A_REPLACEMENT
#define JITTER_THIS_IS_A_REPLACEMENT 1

    /* User code for !REPLACEMENT-primitive-car/fR/retR . */
  {
/* User-specified code, user code block part: beginning. */

    JITTERLISPVM_CHECK_TYPES_1(CONS, JITTER_ARGF0);
    JITTERLISP_CAR_(JITTER_TOP_MAINSTACK(), JITTER_TOP_MAINSTACK());
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for !REPLACEMENT-primitive-car/fR/retR . */

  //fprintf (stderr, "..Executed replacement instruction %s\n", "!REPLACEMENT-primitive-car/fR/retR");
  //fprintf (stderr, "..Executed instruction %s\n", "!REPLACEMENT-primitive-car/fR/retR");
//#endif // #if 0
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
#ifdef JITTER_REPLICATE
  {
    /* Advance the instruction pointer, if any, to skip every
       residual but the last; branch back to replicated
       code. */
    const void *_jitter_back_to_replicated_code_pointer =
      JITTER_ARGP1;
    JITTER_SKIP_RESIDUALS_;
    goto * _jitter_back_to_replicated_code_pointer;
  }
#endif // #ifdef JITTER_REPLICATE

    /* Undefine the !REPLACEMENT-primitive-car/fR/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#ifndef JITTER_REPLICATE
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-primitive-car/fR/retR, _eREPLACEMENT_mprimitive_mcar__fR__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#endif // #ifndef JITTER_REPLICATE
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for !REPLACEMENT-primitive-car/fR/retR, which started with its
       definitions. */
  }
#endif // #if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
/*  End of !REPLACEMENT-primitive-car/fR/retR , a replacement specialised instruction */

  /* Ordinary specialised instruction !REPLACEMENT-primitive-cdr/fR/retR (replacement) */
  /* Omit this specialised instruction altogether unless
     replacements are in fact supported in this
     configuration. */
#if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
  JITTER_INSTRUCTION_PROLOG_(!REPLACEMENT-primitive-cdr/fR/retR, _eREPLACEMENT_mprimitive_mcdr__fR__retR, cold)
  { /* This block begins with definitions for !REPLACEMENT-primitive-cdr/fR/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       301
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         !REPLACEMENT-primitive-cdr/fR/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "primitive-cdr"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "!REPLACEMENT-primitive-cdr/fR/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _eREPLACEMENT_mprimitive_mcdr__fR__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST JITTER_BRANCH
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 2

  /* Define argument-access macros for !REPLACEMENT-primitive-cdr/fR/retR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
    /* The 0th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* When jumping to the non-relocatable part it is important not
   to use a fallback version of JITTER_COMPUTED_GOTO, in order to
   prevent GCC from tail-merging. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
    /* Jump to non-relocatable code. */
    JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);

    /* Here the residual arity is given as zero: it's too late to
       skip residuals, since we've already jumped and this code is
       unreachable.  The instruction pointer, if any, is advanced
       in the non-relocatable code. */
    JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-primitive-cdr/fR/retR, _eREPLACEMENT_mprimitive_mcdr__fR__retR, 0)

    /* Relocated code will jump to this label in non-relocated code. */
  JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
    JITTER_COMMENT_IN_ASM_("!REPLACEMENT-primitive-cdr/fR/retR non-relocatable code");
#endif // #ifdef JITTER_REPLICATE
#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of !REPLACEMENT-primitive-cdr/fR/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  no. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
//#if 0
  //fprintf (stderr, "Executing instruction %s..\n", "!REPLACEMENT-primitive-cdr/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing replacement instruction %s..\n", "!REPLACEMENT-primitive-cdr/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing non-relocatable instruction %s with JITTER_SPECIALIZED_INSTRUCTION_WORD_NO=%i..\n", "!REPLACEMENT-primitive-cdr/fR/retR", (int) JITTER_SPECIALIZED_INSTRUCTION_WORD_NO); fflush (stderr);
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#undef JITTER_THIS_IS_A_REPLACEMENT
#define JITTER_THIS_IS_A_REPLACEMENT 1

    /* User code for !REPLACEMENT-primitive-cdr/fR/retR . */
  {
/* User-specified code, user code block part: beginning. */

    JITTERLISPVM_CHECK_TYPES_1(CONS, JITTER_ARGF0);
    JITTERLISP_CDR_(JITTER_TOP_MAINSTACK(), JITTER_TOP_MAINSTACK());
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for !REPLACEMENT-primitive-cdr/fR/retR . */

  //fprintf (stderr, "..Executed replacement instruction %s\n", "!REPLACEMENT-primitive-cdr/fR/retR");
  //fprintf (stderr, "..Executed instruction %s\n", "!REPLACEMENT-primitive-cdr/fR/retR");
//#endif // #if 0
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
#ifdef JITTER_REPLICATE
  {
    /* Advance the instruction pointer, if any, to skip every
       residual but the last; branch back to replicated
       code. */
    const void *_jitter_back_to_replicated_code_pointer =
      JITTER_ARGP1;
    JITTER_SKIP_RESIDUALS_;
    goto * _jitter_back_to_replicated_code_pointer;
  }
#endif // #ifdef JITTER_REPLICATE

    /* Undefine the !REPLACEMENT-primitive-cdr/fR/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#ifndef JITTER_REPLICATE
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-primitive-cdr/fR/retR, _eREPLACEMENT_mprimitive_mcdr__fR__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#endif // #ifndef JITTER_REPLICATE
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for !REPLACEMENT-primitive-cdr/fR/retR, which started with its
       definitions. */
  }
#endif // #if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
/*  End of !REPLACEMENT-primitive-cdr/fR/retR , a replacement specialised instruction */

  /* Ordinary specialised instruction !REPLACEMENT-primitive-fixnum-eqp/fR/retR (replacement) */
  /* Omit this specialised instruction altogether unless
     replacements are in fact supported in this
     configuration. */
#if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
  JITTER_INSTRUCTION_PROLOG_(!REPLACEMENT-primitive-fixnum-eqp/fR/retR, _eREPLACEMENT_mprimitive_mfixnum_meqp__fR__retR, cold)
  { /* This block begins with definitions for !REPLACEMENT-primitive-fixnum-eqp/fR/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       302
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         !REPLACEMENT-primitive-fixnum-eqp/fR/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "primitive-fixnum-eqp"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "!REPLACEMENT-primitive-fixnum-eqp/fR/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _eREPLACEMENT_mprimitive_mfixnum_meqp__fR__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST JITTER_BRANCH
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 2

  /* Define argument-access macros for !REPLACEMENT-primitive-fixnum-eqp/fR/retR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
    /* The 0th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* When jumping to the non-relocatable part it is important not
   to use a fallback version of JITTER_COMPUTED_GOTO, in order to
   prevent GCC from tail-merging. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
    /* Jump to non-relocatable code. */
    JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);

    /* Here the residual arity is given as zero: it's too late to
       skip residuals, since we've already jumped and this code is
       unreachable.  The instruction pointer, if any, is advanced
       in the non-relocatable code. */
    JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-primitive-fixnum-eqp/fR/retR, _eREPLACEMENT_mprimitive_mfixnum_meqp__fR__retR, 0)

    /* Relocated code will jump to this label in non-relocated code. */
  JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
    JITTER_COMMENT_IN_ASM_("!REPLACEMENT-primitive-fixnum-eqp/fR/retR non-relocatable code");
#endif // #ifdef JITTER_REPLICATE
#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of !REPLACEMENT-primitive-fixnum-eqp/fR/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  no. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
//#if 0
  //fprintf (stderr, "Executing instruction %s..\n", "!REPLACEMENT-primitive-fixnum-eqp/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing replacement instruction %s..\n", "!REPLACEMENT-primitive-fixnum-eqp/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing non-relocatable instruction %s with JITTER_SPECIALIZED_INSTRUCTION_WORD_NO=%i..\n", "!REPLACEMENT-primitive-fixnum-eqp/fR/retR", (int) JITTER_SPECIALIZED_INSTRUCTION_WORD_NO); fflush (stderr);
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#undef JITTER_THIS_IS_A_REPLACEMENT
#define JITTER_THIS_IS_A_REPLACEMENT 1

    /* User code for !REPLACEMENT-primitive-fixnum-eqp/fR/retR . */
  {
/* User-specified code, user code block part: beginning. */

    JITTERLISPVM_CHECK_TYPES_2(FIXNUM, FIXNUM, JITTER_ARGF0);
    JITTERLISP_EQP_(JITTER_TOP_MAINSTACK(),
                    JITTER_UNDER_TOP_MAINSTACK(), JITTER_TOP_MAINSTACK());
    JITTER_NIP_MAINSTACK();
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for !REPLACEMENT-primitive-fixnum-eqp/fR/retR . */

  //fprintf (stderr, "..Executed replacement instruction %s\n", "!REPLACEMENT-primitive-fixnum-eqp/fR/retR");
  //fprintf (stderr, "..Executed instruction %s\n", "!REPLACEMENT-primitive-fixnum-eqp/fR/retR");
//#endif // #if 0
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
#ifdef JITTER_REPLICATE
  {
    /* Advance the instruction pointer, if any, to skip every
       residual but the last; branch back to replicated
       code. */
    const void *_jitter_back_to_replicated_code_pointer =
      JITTER_ARGP1;
    JITTER_SKIP_RESIDUALS_;
    goto * _jitter_back_to_replicated_code_pointer;
  }
#endif // #ifdef JITTER_REPLICATE

    /* Undefine the !REPLACEMENT-primitive-fixnum-eqp/fR/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#ifndef JITTER_REPLICATE
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-primitive-fixnum-eqp/fR/retR, _eREPLACEMENT_mprimitive_mfixnum_meqp__fR__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#endif // #ifndef JITTER_REPLICATE
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for !REPLACEMENT-primitive-fixnum-eqp/fR/retR, which started with its
       definitions. */
  }
#endif // #if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
/*  End of !REPLACEMENT-primitive-fixnum-eqp/fR/retR , a replacement specialised instruction */

  /* Ordinary specialised instruction !REPLACEMENT-primitive-fixnum-not-eqp/fR/retR (replacement) */
  /* Omit this specialised instruction altogether unless
     replacements are in fact supported in this
     configuration. */
#if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
  JITTER_INSTRUCTION_PROLOG_(!REPLACEMENT-primitive-fixnum-not-eqp/fR/retR, _eREPLACEMENT_mprimitive_mfixnum_mnot_meqp__fR__retR, cold)
  { /* This block begins with definitions for !REPLACEMENT-primitive-fixnum-not-eqp/fR/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       303
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         !REPLACEMENT-primitive-fixnum-not-eqp/fR/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "primitive-fixnum-not-eqp"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "!REPLACEMENT-primitive-fixnum-not-eqp/fR/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _eREPLACEMENT_mprimitive_mfixnum_mnot_meqp__fR__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST JITTER_BRANCH
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 2

  /* Define argument-access macros for !REPLACEMENT-primitive-fixnum-not-eqp/fR/retR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
    /* The 0th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* When jumping to the non-relocatable part it is important not
   to use a fallback version of JITTER_COMPUTED_GOTO, in order to
   prevent GCC from tail-merging. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
    /* Jump to non-relocatable code. */
    JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);

    /* Here the residual arity is given as zero: it's too late to
       skip residuals, since we've already jumped and this code is
       unreachable.  The instruction pointer, if any, is advanced
       in the non-relocatable code. */
    JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-primitive-fixnum-not-eqp/fR/retR, _eREPLACEMENT_mprimitive_mfixnum_mnot_meqp__fR__retR, 0)

    /* Relocated code will jump to this label in non-relocated code. */
  JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
    JITTER_COMMENT_IN_ASM_("!REPLACEMENT-primitive-fixnum-not-eqp/fR/retR non-relocatable code");
#endif // #ifdef JITTER_REPLICATE
#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of !REPLACEMENT-primitive-fixnum-not-eqp/fR/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  no. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
//#if 0
  //fprintf (stderr, "Executing instruction %s..\n", "!REPLACEMENT-primitive-fixnum-not-eqp/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing replacement instruction %s..\n", "!REPLACEMENT-primitive-fixnum-not-eqp/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing non-relocatable instruction %s with JITTER_SPECIALIZED_INSTRUCTION_WORD_NO=%i..\n", "!REPLACEMENT-primitive-fixnum-not-eqp/fR/retR", (int) JITTER_SPECIALIZED_INSTRUCTION_WORD_NO); fflush (stderr);
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#undef JITTER_THIS_IS_A_REPLACEMENT
#define JITTER_THIS_IS_A_REPLACEMENT 1

    /* User code for !REPLACEMENT-primitive-fixnum-not-eqp/fR/retR . */
  {
/* User-specified code, user code block part: beginning. */

    JITTERLISPVM_CHECK_TYPES_2(FIXNUM, FIXNUM, JITTER_ARGF0);
    JITTERLISP_NOT_EQP_(JITTER_TOP_MAINSTACK(),
                        JITTER_UNDER_TOP_MAINSTACK(), JITTER_TOP_MAINSTACK());
    JITTER_NIP_MAINSTACK();
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for !REPLACEMENT-primitive-fixnum-not-eqp/fR/retR . */

  //fprintf (stderr, "..Executed replacement instruction %s\n", "!REPLACEMENT-primitive-fixnum-not-eqp/fR/retR");
  //fprintf (stderr, "..Executed instruction %s\n", "!REPLACEMENT-primitive-fixnum-not-eqp/fR/retR");
//#endif // #if 0
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
#ifdef JITTER_REPLICATE
  {
    /* Advance the instruction pointer, if any, to skip every
       residual but the last; branch back to replicated
       code. */
    const void *_jitter_back_to_replicated_code_pointer =
      JITTER_ARGP1;
    JITTER_SKIP_RESIDUALS_;
    goto * _jitter_back_to_replicated_code_pointer;
  }
#endif // #ifdef JITTER_REPLICATE

    /* Undefine the !REPLACEMENT-primitive-fixnum-not-eqp/fR/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#ifndef JITTER_REPLICATE
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-primitive-fixnum-not-eqp/fR/retR, _eREPLACEMENT_mprimitive_mfixnum_mnot_meqp__fR__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#endif // #ifndef JITTER_REPLICATE
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for !REPLACEMENT-primitive-fixnum-not-eqp/fR/retR, which started with its
       definitions. */
  }
#endif // #if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
/*  End of !REPLACEMENT-primitive-fixnum-not-eqp/fR/retR , a replacement specialised instruction */

  /* Ordinary specialised instruction !REPLACEMENT-primitive-greaterp/fR/retR (replacement) */
  /* Omit this specialised instruction altogether unless
     replacements are in fact supported in this
     configuration. */
#if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
  JITTER_INSTRUCTION_PROLOG_(!REPLACEMENT-primitive-greaterp/fR/retR, _eREPLACEMENT_mprimitive_mgreaterp__fR__retR, cold)
  { /* This block begins with definitions for !REPLACEMENT-primitive-greaterp/fR/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       304
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         !REPLACEMENT-primitive-greaterp/fR/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "primitive-greaterp"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "!REPLACEMENT-primitive-greaterp/fR/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _eREPLACEMENT_mprimitive_mgreaterp__fR__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST JITTER_BRANCH
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 2

  /* Define argument-access macros for !REPLACEMENT-primitive-greaterp/fR/retR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
    /* The 0th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* When jumping to the non-relocatable part it is important not
   to use a fallback version of JITTER_COMPUTED_GOTO, in order to
   prevent GCC from tail-merging. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
    /* Jump to non-relocatable code. */
    JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);

    /* Here the residual arity is given as zero: it's too late to
       skip residuals, since we've already jumped and this code is
       unreachable.  The instruction pointer, if any, is advanced
       in the non-relocatable code. */
    JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-primitive-greaterp/fR/retR, _eREPLACEMENT_mprimitive_mgreaterp__fR__retR, 0)

    /* Relocated code will jump to this label in non-relocated code. */
  JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
    JITTER_COMMENT_IN_ASM_("!REPLACEMENT-primitive-greaterp/fR/retR non-relocatable code");
#endif // #ifdef JITTER_REPLICATE
#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of !REPLACEMENT-primitive-greaterp/fR/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  no. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
//#if 0
  //fprintf (stderr, "Executing instruction %s..\n", "!REPLACEMENT-primitive-greaterp/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing replacement instruction %s..\n", "!REPLACEMENT-primitive-greaterp/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing non-relocatable instruction %s with JITTER_SPECIALIZED_INSTRUCTION_WORD_NO=%i..\n", "!REPLACEMENT-primitive-greaterp/fR/retR", (int) JITTER_SPECIALIZED_INSTRUCTION_WORD_NO); fflush (stderr);
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#undef JITTER_THIS_IS_A_REPLACEMENT
#define JITTER_THIS_IS_A_REPLACEMENT 1

    /* User code for !REPLACEMENT-primitive-greaterp/fR/retR . */
  {
/* User-specified code, user code block part: beginning. */

    JITTERLISPVM_CHECK_TYPES_2(FIXNUM, FIXNUM, JITTER_ARGF0);
    JITTERLISP_GREATERP_(JITTER_TOP_MAINSTACK(),
                         JITTER_UNDER_TOP_MAINSTACK(), JITTER_TOP_MAINSTACK());
    JITTER_NIP_MAINSTACK();
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for !REPLACEMENT-primitive-greaterp/fR/retR . */

  //fprintf (stderr, "..Executed replacement instruction %s\n", "!REPLACEMENT-primitive-greaterp/fR/retR");
  //fprintf (stderr, "..Executed instruction %s\n", "!REPLACEMENT-primitive-greaterp/fR/retR");
//#endif // #if 0
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
#ifdef JITTER_REPLICATE
  {
    /* Advance the instruction pointer, if any, to skip every
       residual but the last; branch back to replicated
       code. */
    const void *_jitter_back_to_replicated_code_pointer =
      JITTER_ARGP1;
    JITTER_SKIP_RESIDUALS_;
    goto * _jitter_back_to_replicated_code_pointer;
  }
#endif // #ifdef JITTER_REPLICATE

    /* Undefine the !REPLACEMENT-primitive-greaterp/fR/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#ifndef JITTER_REPLICATE
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-primitive-greaterp/fR/retR, _eREPLACEMENT_mprimitive_mgreaterp__fR__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#endif // #ifndef JITTER_REPLICATE
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for !REPLACEMENT-primitive-greaterp/fR/retR, which started with its
       definitions. */
  }
#endif // #if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
/*  End of !REPLACEMENT-primitive-greaterp/fR/retR , a replacement specialised instruction */

  /* Ordinary specialised instruction !REPLACEMENT-primitive-lessp/fR/retR (replacement) */
  /* Omit this specialised instruction altogether unless
     replacements are in fact supported in this
     configuration. */
#if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
  JITTER_INSTRUCTION_PROLOG_(!REPLACEMENT-primitive-lessp/fR/retR, _eREPLACEMENT_mprimitive_mlessp__fR__retR, cold)
  { /* This block begins with definitions for !REPLACEMENT-primitive-lessp/fR/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       305
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         !REPLACEMENT-primitive-lessp/fR/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "primitive-lessp"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "!REPLACEMENT-primitive-lessp/fR/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _eREPLACEMENT_mprimitive_mlessp__fR__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST JITTER_BRANCH
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 2

  /* Define argument-access macros for !REPLACEMENT-primitive-lessp/fR/retR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
    /* The 0th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* When jumping to the non-relocatable part it is important not
   to use a fallback version of JITTER_COMPUTED_GOTO, in order to
   prevent GCC from tail-merging. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
    /* Jump to non-relocatable code. */
    JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);

    /* Here the residual arity is given as zero: it's too late to
       skip residuals, since we've already jumped and this code is
       unreachable.  The instruction pointer, if any, is advanced
       in the non-relocatable code. */
    JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-primitive-lessp/fR/retR, _eREPLACEMENT_mprimitive_mlessp__fR__retR, 0)

    /* Relocated code will jump to this label in non-relocated code. */
  JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
    JITTER_COMMENT_IN_ASM_("!REPLACEMENT-primitive-lessp/fR/retR non-relocatable code");
#endif // #ifdef JITTER_REPLICATE
#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of !REPLACEMENT-primitive-lessp/fR/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  no. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
//#if 0
  //fprintf (stderr, "Executing instruction %s..\n", "!REPLACEMENT-primitive-lessp/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing replacement instruction %s..\n", "!REPLACEMENT-primitive-lessp/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing non-relocatable instruction %s with JITTER_SPECIALIZED_INSTRUCTION_WORD_NO=%i..\n", "!REPLACEMENT-primitive-lessp/fR/retR", (int) JITTER_SPECIALIZED_INSTRUCTION_WORD_NO); fflush (stderr);
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#undef JITTER_THIS_IS_A_REPLACEMENT
#define JITTER_THIS_IS_A_REPLACEMENT 1

    /* User code for !REPLACEMENT-primitive-lessp/fR/retR . */
  {
/* User-specified code, user code block part: beginning. */

    JITTERLISPVM_CHECK_TYPES_2(FIXNUM, FIXNUM, JITTER_ARGF0);
    JITTERLISP_LESSP_(JITTER_TOP_MAINSTACK(),
                      JITTER_UNDER_TOP_MAINSTACK(), JITTER_TOP_MAINSTACK());
    JITTER_NIP_MAINSTACK();
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for !REPLACEMENT-primitive-lessp/fR/retR . */

  //fprintf (stderr, "..Executed replacement instruction %s\n", "!REPLACEMENT-primitive-lessp/fR/retR");
  //fprintf (stderr, "..Executed instruction %s\n", "!REPLACEMENT-primitive-lessp/fR/retR");
//#endif // #if 0
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
#ifdef JITTER_REPLICATE
  {
    /* Advance the instruction pointer, if any, to skip every
       residual but the last; branch back to replicated
       code. */
    const void *_jitter_back_to_replicated_code_pointer =
      JITTER_ARGP1;
    JITTER_SKIP_RESIDUALS_;
    goto * _jitter_back_to_replicated_code_pointer;
  }
#endif // #ifdef JITTER_REPLICATE

    /* Undefine the !REPLACEMENT-primitive-lessp/fR/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#ifndef JITTER_REPLICATE
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-primitive-lessp/fR/retR, _eREPLACEMENT_mprimitive_mlessp__fR__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#endif // #ifndef JITTER_REPLICATE
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for !REPLACEMENT-primitive-lessp/fR/retR, which started with its
       definitions. */
  }
#endif // #if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
/*  End of !REPLACEMENT-primitive-lessp/fR/retR , a replacement specialised instruction */

  /* Ordinary specialised instruction !REPLACEMENT-primitive-negate/fR/retR (replacement) */
  /* Omit this specialised instruction altogether unless
     replacements are in fact supported in this
     configuration. */
#if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
  JITTER_INSTRUCTION_PROLOG_(!REPLACEMENT-primitive-negate/fR/retR, _eREPLACEMENT_mprimitive_mnegate__fR__retR, cold)
  { /* This block begins with definitions for !REPLACEMENT-primitive-negate/fR/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       306
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         !REPLACEMENT-primitive-negate/fR/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "primitive-negate"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "!REPLACEMENT-primitive-negate/fR/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _eREPLACEMENT_mprimitive_mnegate__fR__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST JITTER_BRANCH
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 2

  /* Define argument-access macros for !REPLACEMENT-primitive-negate/fR/retR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
    /* The 0th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* When jumping to the non-relocatable part it is important not
   to use a fallback version of JITTER_COMPUTED_GOTO, in order to
   prevent GCC from tail-merging. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
    /* Jump to non-relocatable code. */
    JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);

    /* Here the residual arity is given as zero: it's too late to
       skip residuals, since we've already jumped and this code is
       unreachable.  The instruction pointer, if any, is advanced
       in the non-relocatable code. */
    JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-primitive-negate/fR/retR, _eREPLACEMENT_mprimitive_mnegate__fR__retR, 0)

    /* Relocated code will jump to this label in non-relocated code. */
  JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
    JITTER_COMMENT_IN_ASM_("!REPLACEMENT-primitive-negate/fR/retR non-relocatable code");
#endif // #ifdef JITTER_REPLICATE
#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of !REPLACEMENT-primitive-negate/fR/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  no. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
//#if 0
  //fprintf (stderr, "Executing instruction %s..\n", "!REPLACEMENT-primitive-negate/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing replacement instruction %s..\n", "!REPLACEMENT-primitive-negate/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing non-relocatable instruction %s with JITTER_SPECIALIZED_INSTRUCTION_WORD_NO=%i..\n", "!REPLACEMENT-primitive-negate/fR/retR", (int) JITTER_SPECIALIZED_INSTRUCTION_WORD_NO); fflush (stderr);
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#undef JITTER_THIS_IS_A_REPLACEMENT
#define JITTER_THIS_IS_A_REPLACEMENT 1

    /* User code for !REPLACEMENT-primitive-negate/fR/retR . */
  {
/* User-specified code, user code block part: beginning. */

    JITTERLISPVM_CHECK_TYPES_1(FIXNUM, JITTER_ARGF0);
    JITTERLISP_NEGATE_OR_OVERFLOW_(JITTER_TOP_MAINSTACK(),
                                   JITTER_TOP_MAINSTACK(),
                                   JITTER_ARGF0);
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for !REPLACEMENT-primitive-negate/fR/retR . */

  //fprintf (stderr, "..Executed replacement instruction %s\n", "!REPLACEMENT-primitive-negate/fR/retR");
  //fprintf (stderr, "..Executed instruction %s\n", "!REPLACEMENT-primitive-negate/fR/retR");
//#endif // #if 0
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
#ifdef JITTER_REPLICATE
  {
    /* Advance the instruction pointer, if any, to skip every
       residual but the last; branch back to replicated
       code. */
    const void *_jitter_back_to_replicated_code_pointer =
      JITTER_ARGP1;
    JITTER_SKIP_RESIDUALS_;
    goto * _jitter_back_to_replicated_code_pointer;
  }
#endif // #ifdef JITTER_REPLICATE

    /* Undefine the !REPLACEMENT-primitive-negate/fR/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#ifndef JITTER_REPLICATE
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-primitive-negate/fR/retR, _eREPLACEMENT_mprimitive_mnegate__fR__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#endif // #ifndef JITTER_REPLICATE
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for !REPLACEMENT-primitive-negate/fR/retR, which started with its
       definitions. */
  }
#endif // #if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
/*  End of !REPLACEMENT-primitive-negate/fR/retR , a replacement specialised instruction */

  /* Ordinary specialised instruction !REPLACEMENT-primitive-negativep/fR/retR (replacement) */
  /* Omit this specialised instruction altogether unless
     replacements are in fact supported in this
     configuration. */
#if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
  JITTER_INSTRUCTION_PROLOG_(!REPLACEMENT-primitive-negativep/fR/retR, _eREPLACEMENT_mprimitive_mnegativep__fR__retR, cold)
  { /* This block begins with definitions for !REPLACEMENT-primitive-negativep/fR/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       307
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         !REPLACEMENT-primitive-negativep/fR/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "primitive-negativep"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "!REPLACEMENT-primitive-negativep/fR/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _eREPLACEMENT_mprimitive_mnegativep__fR__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST JITTER_BRANCH
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 2

  /* Define argument-access macros for !REPLACEMENT-primitive-negativep/fR/retR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
    /* The 0th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* When jumping to the non-relocatable part it is important not
   to use a fallback version of JITTER_COMPUTED_GOTO, in order to
   prevent GCC from tail-merging. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
    /* Jump to non-relocatable code. */
    JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);

    /* Here the residual arity is given as zero: it's too late to
       skip residuals, since we've already jumped and this code is
       unreachable.  The instruction pointer, if any, is advanced
       in the non-relocatable code. */
    JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-primitive-negativep/fR/retR, _eREPLACEMENT_mprimitive_mnegativep__fR__retR, 0)

    /* Relocated code will jump to this label in non-relocated code. */
  JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
    JITTER_COMMENT_IN_ASM_("!REPLACEMENT-primitive-negativep/fR/retR non-relocatable code");
#endif // #ifdef JITTER_REPLICATE
#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of !REPLACEMENT-primitive-negativep/fR/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  no. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
//#if 0
  //fprintf (stderr, "Executing instruction %s..\n", "!REPLACEMENT-primitive-negativep/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing replacement instruction %s..\n", "!REPLACEMENT-primitive-negativep/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing non-relocatable instruction %s with JITTER_SPECIALIZED_INSTRUCTION_WORD_NO=%i..\n", "!REPLACEMENT-primitive-negativep/fR/retR", (int) JITTER_SPECIALIZED_INSTRUCTION_WORD_NO); fflush (stderr);
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#undef JITTER_THIS_IS_A_REPLACEMENT
#define JITTER_THIS_IS_A_REPLACEMENT 1

    /* User code for !REPLACEMENT-primitive-negativep/fR/retR . */
  {
/* User-specified code, user code block part: beginning. */

    JITTERLISPVM_CHECK_TYPES_1(FIXNUM, JITTER_ARGF0);
    JITTERLISP_NEGATIVEP_(JITTER_TOP_MAINSTACK(), JITTER_TOP_MAINSTACK());
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for !REPLACEMENT-primitive-negativep/fR/retR . */

  //fprintf (stderr, "..Executed replacement instruction %s\n", "!REPLACEMENT-primitive-negativep/fR/retR");
  //fprintf (stderr, "..Executed instruction %s\n", "!REPLACEMENT-primitive-negativep/fR/retR");
//#endif // #if 0
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
#ifdef JITTER_REPLICATE
  {
    /* Advance the instruction pointer, if any, to skip every
       residual but the last; branch back to replicated
       code. */
    const void *_jitter_back_to_replicated_code_pointer =
      JITTER_ARGP1;
    JITTER_SKIP_RESIDUALS_;
    goto * _jitter_back_to_replicated_code_pointer;
  }
#endif // #ifdef JITTER_REPLICATE

    /* Undefine the !REPLACEMENT-primitive-negativep/fR/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#ifndef JITTER_REPLICATE
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-primitive-negativep/fR/retR, _eREPLACEMENT_mprimitive_mnegativep__fR__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#endif // #ifndef JITTER_REPLICATE
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for !REPLACEMENT-primitive-negativep/fR/retR, which started with its
       definitions. */
  }
#endif // #if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
/*  End of !REPLACEMENT-primitive-negativep/fR/retR , a replacement specialised instruction */

  /* Ordinary specialised instruction !REPLACEMENT-primitive-non-negativep/fR/retR (replacement) */
  /* Omit this specialised instruction altogether unless
     replacements are in fact supported in this
     configuration. */
#if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
  JITTER_INSTRUCTION_PROLOG_(!REPLACEMENT-primitive-non-negativep/fR/retR, _eREPLACEMENT_mprimitive_mnon_mnegativep__fR__retR, cold)
  { /* This block begins with definitions for !REPLACEMENT-primitive-non-negativep/fR/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       308
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         !REPLACEMENT-primitive-non-negativep/fR/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "primitive-non-negativep"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "!REPLACEMENT-primitive-non-negativep/fR/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _eREPLACEMENT_mprimitive_mnon_mnegativep__fR__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST JITTER_BRANCH
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 2

  /* Define argument-access macros for !REPLACEMENT-primitive-non-negativep/fR/retR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
    /* The 0th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* When jumping to the non-relocatable part it is important not
   to use a fallback version of JITTER_COMPUTED_GOTO, in order to
   prevent GCC from tail-merging. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
    /* Jump to non-relocatable code. */
    JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);

    /* Here the residual arity is given as zero: it's too late to
       skip residuals, since we've already jumped and this code is
       unreachable.  The instruction pointer, if any, is advanced
       in the non-relocatable code. */
    JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-primitive-non-negativep/fR/retR, _eREPLACEMENT_mprimitive_mnon_mnegativep__fR__retR, 0)

    /* Relocated code will jump to this label in non-relocated code. */
  JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
    JITTER_COMMENT_IN_ASM_("!REPLACEMENT-primitive-non-negativep/fR/retR non-relocatable code");
#endif // #ifdef JITTER_REPLICATE
#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of !REPLACEMENT-primitive-non-negativep/fR/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  no. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
//#if 0
  //fprintf (stderr, "Executing instruction %s..\n", "!REPLACEMENT-primitive-non-negativep/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing replacement instruction %s..\n", "!REPLACEMENT-primitive-non-negativep/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing non-relocatable instruction %s with JITTER_SPECIALIZED_INSTRUCTION_WORD_NO=%i..\n", "!REPLACEMENT-primitive-non-negativep/fR/retR", (int) JITTER_SPECIALIZED_INSTRUCTION_WORD_NO); fflush (stderr);
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#undef JITTER_THIS_IS_A_REPLACEMENT
#define JITTER_THIS_IS_A_REPLACEMENT 1

    /* User code for !REPLACEMENT-primitive-non-negativep/fR/retR . */
  {
/* User-specified code, user code block part: beginning. */

    JITTERLISPVM_CHECK_TYPES_1(FIXNUM, JITTER_ARGF0);
    JITTERLISP_NON_NEGATIVEP_(JITTER_TOP_MAINSTACK(), JITTER_TOP_MAINSTACK());
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for !REPLACEMENT-primitive-non-negativep/fR/retR . */

  //fprintf (stderr, "..Executed replacement instruction %s\n", "!REPLACEMENT-primitive-non-negativep/fR/retR");
  //fprintf (stderr, "..Executed instruction %s\n", "!REPLACEMENT-primitive-non-negativep/fR/retR");
//#endif // #if 0
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
#ifdef JITTER_REPLICATE
  {
    /* Advance the instruction pointer, if any, to skip every
       residual but the last; branch back to replicated
       code. */
    const void *_jitter_back_to_replicated_code_pointer =
      JITTER_ARGP1;
    JITTER_SKIP_RESIDUALS_;
    goto * _jitter_back_to_replicated_code_pointer;
  }
#endif // #ifdef JITTER_REPLICATE

    /* Undefine the !REPLACEMENT-primitive-non-negativep/fR/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#ifndef JITTER_REPLICATE
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-primitive-non-negativep/fR/retR, _eREPLACEMENT_mprimitive_mnon_mnegativep__fR__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#endif // #ifndef JITTER_REPLICATE
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for !REPLACEMENT-primitive-non-negativep/fR/retR, which started with its
       definitions. */
  }
#endif // #if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
/*  End of !REPLACEMENT-primitive-non-negativep/fR/retR , a replacement specialised instruction */

  /* Ordinary specialised instruction !REPLACEMENT-primitive-non-positivep/fR/retR (replacement) */
  /* Omit this specialised instruction altogether unless
     replacements are in fact supported in this
     configuration. */
#if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
  JITTER_INSTRUCTION_PROLOG_(!REPLACEMENT-primitive-non-positivep/fR/retR, _eREPLACEMENT_mprimitive_mnon_mpositivep__fR__retR, cold)
  { /* This block begins with definitions for !REPLACEMENT-primitive-non-positivep/fR/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       309
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         !REPLACEMENT-primitive-non-positivep/fR/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "primitive-non-positivep"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "!REPLACEMENT-primitive-non-positivep/fR/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _eREPLACEMENT_mprimitive_mnon_mpositivep__fR__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST JITTER_BRANCH
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 2

  /* Define argument-access macros for !REPLACEMENT-primitive-non-positivep/fR/retR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
    /* The 0th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* When jumping to the non-relocatable part it is important not
   to use a fallback version of JITTER_COMPUTED_GOTO, in order to
   prevent GCC from tail-merging. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
    /* Jump to non-relocatable code. */
    JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);

    /* Here the residual arity is given as zero: it's too late to
       skip residuals, since we've already jumped and this code is
       unreachable.  The instruction pointer, if any, is advanced
       in the non-relocatable code. */
    JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-primitive-non-positivep/fR/retR, _eREPLACEMENT_mprimitive_mnon_mpositivep__fR__retR, 0)

    /* Relocated code will jump to this label in non-relocated code. */
  JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
    JITTER_COMMENT_IN_ASM_("!REPLACEMENT-primitive-non-positivep/fR/retR non-relocatable code");
#endif // #ifdef JITTER_REPLICATE
#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of !REPLACEMENT-primitive-non-positivep/fR/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  no. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
//#if 0
  //fprintf (stderr, "Executing instruction %s..\n", "!REPLACEMENT-primitive-non-positivep/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing replacement instruction %s..\n", "!REPLACEMENT-primitive-non-positivep/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing non-relocatable instruction %s with JITTER_SPECIALIZED_INSTRUCTION_WORD_NO=%i..\n", "!REPLACEMENT-primitive-non-positivep/fR/retR", (int) JITTER_SPECIALIZED_INSTRUCTION_WORD_NO); fflush (stderr);
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#undef JITTER_THIS_IS_A_REPLACEMENT
#define JITTER_THIS_IS_A_REPLACEMENT 1

    /* User code for !REPLACEMENT-primitive-non-positivep/fR/retR . */
  {
/* User-specified code, user code block part: beginning. */

    JITTERLISPVM_CHECK_TYPES_1(FIXNUM, JITTER_ARGF0);
    JITTERLISP_NON_POSITIVEP_(JITTER_TOP_MAINSTACK(), JITTER_TOP_MAINSTACK());
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for !REPLACEMENT-primitive-non-positivep/fR/retR . */

  //fprintf (stderr, "..Executed replacement instruction %s\n", "!REPLACEMENT-primitive-non-positivep/fR/retR");
  //fprintf (stderr, "..Executed instruction %s\n", "!REPLACEMENT-primitive-non-positivep/fR/retR");
//#endif // #if 0
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
#ifdef JITTER_REPLICATE
  {
    /* Advance the instruction pointer, if any, to skip every
       residual but the last; branch back to replicated
       code. */
    const void *_jitter_back_to_replicated_code_pointer =
      JITTER_ARGP1;
    JITTER_SKIP_RESIDUALS_;
    goto * _jitter_back_to_replicated_code_pointer;
  }
#endif // #ifdef JITTER_REPLICATE

    /* Undefine the !REPLACEMENT-primitive-non-positivep/fR/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#ifndef JITTER_REPLICATE
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-primitive-non-positivep/fR/retR, _eREPLACEMENT_mprimitive_mnon_mpositivep__fR__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#endif // #ifndef JITTER_REPLICATE
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for !REPLACEMENT-primitive-non-positivep/fR/retR, which started with its
       definitions. */
  }
#endif // #if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
/*  End of !REPLACEMENT-primitive-non-positivep/fR/retR , a replacement specialised instruction */

  /* Ordinary specialised instruction !REPLACEMENT-primitive-non-zerop/fR/retR (replacement) */
  /* Omit this specialised instruction altogether unless
     replacements are in fact supported in this
     configuration. */
#if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
  JITTER_INSTRUCTION_PROLOG_(!REPLACEMENT-primitive-non-zerop/fR/retR, _eREPLACEMENT_mprimitive_mnon_mzerop__fR__retR, cold)
  { /* This block begins with definitions for !REPLACEMENT-primitive-non-zerop/fR/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       310
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         !REPLACEMENT-primitive-non-zerop/fR/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "primitive-non-zerop"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "!REPLACEMENT-primitive-non-zerop/fR/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _eREPLACEMENT_mprimitive_mnon_mzerop__fR__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST JITTER_BRANCH
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 2

  /* Define argument-access macros for !REPLACEMENT-primitive-non-zerop/fR/retR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
    /* The 0th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* When jumping to the non-relocatable part it is important not
   to use a fallback version of JITTER_COMPUTED_GOTO, in order to
   prevent GCC from tail-merging. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
    /* Jump to non-relocatable code. */
    JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);

    /* Here the residual arity is given as zero: it's too late to
       skip residuals, since we've already jumped and this code is
       unreachable.  The instruction pointer, if any, is advanced
       in the non-relocatable code. */
    JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-primitive-non-zerop/fR/retR, _eREPLACEMENT_mprimitive_mnon_mzerop__fR__retR, 0)

    /* Relocated code will jump to this label in non-relocated code. */
  JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
    JITTER_COMMENT_IN_ASM_("!REPLACEMENT-primitive-non-zerop/fR/retR non-relocatable code");
#endif // #ifdef JITTER_REPLICATE
#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of !REPLACEMENT-primitive-non-zerop/fR/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  no. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
//#if 0
  //fprintf (stderr, "Executing instruction %s..\n", "!REPLACEMENT-primitive-non-zerop/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing replacement instruction %s..\n", "!REPLACEMENT-primitive-non-zerop/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing non-relocatable instruction %s with JITTER_SPECIALIZED_INSTRUCTION_WORD_NO=%i..\n", "!REPLACEMENT-primitive-non-zerop/fR/retR", (int) JITTER_SPECIALIZED_INSTRUCTION_WORD_NO); fflush (stderr);
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#undef JITTER_THIS_IS_A_REPLACEMENT
#define JITTER_THIS_IS_A_REPLACEMENT 1

    /* User code for !REPLACEMENT-primitive-non-zerop/fR/retR . */
  {
/* User-specified code, user code block part: beginning. */

    JITTERLISPVM_CHECK_TYPES_1(FIXNUM, JITTER_ARGF0);
    JITTERLISP_NON_ZEROP_(JITTER_TOP_MAINSTACK(), JITTER_TOP_MAINSTACK());
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for !REPLACEMENT-primitive-non-zerop/fR/retR . */

  //fprintf (stderr, "..Executed replacement instruction %s\n", "!REPLACEMENT-primitive-non-zerop/fR/retR");
  //fprintf (stderr, "..Executed instruction %s\n", "!REPLACEMENT-primitive-non-zerop/fR/retR");
//#endif // #if 0
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
#ifdef JITTER_REPLICATE
  {
    /* Advance the instruction pointer, if any, to skip every
       residual but the last; branch back to replicated
       code. */
    const void *_jitter_back_to_replicated_code_pointer =
      JITTER_ARGP1;
    JITTER_SKIP_RESIDUALS_;
    goto * _jitter_back_to_replicated_code_pointer;
  }
#endif // #ifdef JITTER_REPLICATE

    /* Undefine the !REPLACEMENT-primitive-non-zerop/fR/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#ifndef JITTER_REPLICATE
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-primitive-non-zerop/fR/retR, _eREPLACEMENT_mprimitive_mnon_mzerop__fR__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#endif // #ifndef JITTER_REPLICATE
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for !REPLACEMENT-primitive-non-zerop/fR/retR, which started with its
       definitions. */
  }
#endif // #if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
/*  End of !REPLACEMENT-primitive-non-zerop/fR/retR , a replacement specialised instruction */

  /* Ordinary specialised instruction !REPLACEMENT-primitive-not-greaterp/fR/retR (replacement) */
  /* Omit this specialised instruction altogether unless
     replacements are in fact supported in this
     configuration. */
#if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
  JITTER_INSTRUCTION_PROLOG_(!REPLACEMENT-primitive-not-greaterp/fR/retR, _eREPLACEMENT_mprimitive_mnot_mgreaterp__fR__retR, cold)
  { /* This block begins with definitions for !REPLACEMENT-primitive-not-greaterp/fR/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       311
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         !REPLACEMENT-primitive-not-greaterp/fR/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "primitive-not-greaterp"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "!REPLACEMENT-primitive-not-greaterp/fR/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _eREPLACEMENT_mprimitive_mnot_mgreaterp__fR__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST JITTER_BRANCH
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 2

  /* Define argument-access macros for !REPLACEMENT-primitive-not-greaterp/fR/retR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
    /* The 0th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* When jumping to the non-relocatable part it is important not
   to use a fallback version of JITTER_COMPUTED_GOTO, in order to
   prevent GCC from tail-merging. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
    /* Jump to non-relocatable code. */
    JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);

    /* Here the residual arity is given as zero: it's too late to
       skip residuals, since we've already jumped and this code is
       unreachable.  The instruction pointer, if any, is advanced
       in the non-relocatable code. */
    JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-primitive-not-greaterp/fR/retR, _eREPLACEMENT_mprimitive_mnot_mgreaterp__fR__retR, 0)

    /* Relocated code will jump to this label in non-relocated code. */
  JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
    JITTER_COMMENT_IN_ASM_("!REPLACEMENT-primitive-not-greaterp/fR/retR non-relocatable code");
#endif // #ifdef JITTER_REPLICATE
#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of !REPLACEMENT-primitive-not-greaterp/fR/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  no. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
//#if 0
  //fprintf (stderr, "Executing instruction %s..\n", "!REPLACEMENT-primitive-not-greaterp/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing replacement instruction %s..\n", "!REPLACEMENT-primitive-not-greaterp/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing non-relocatable instruction %s with JITTER_SPECIALIZED_INSTRUCTION_WORD_NO=%i..\n", "!REPLACEMENT-primitive-not-greaterp/fR/retR", (int) JITTER_SPECIALIZED_INSTRUCTION_WORD_NO); fflush (stderr);
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#undef JITTER_THIS_IS_A_REPLACEMENT
#define JITTER_THIS_IS_A_REPLACEMENT 1

    /* User code for !REPLACEMENT-primitive-not-greaterp/fR/retR . */
  {
/* User-specified code, user code block part: beginning. */

    JITTERLISPVM_CHECK_TYPES_2(FIXNUM, FIXNUM, JITTER_ARGF0);
    JITTERLISP_NOTGREATERP_(JITTER_TOP_MAINSTACK(),
                            JITTER_UNDER_TOP_MAINSTACK(),
                            JITTER_TOP_MAINSTACK());
    JITTER_NIP_MAINSTACK();
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for !REPLACEMENT-primitive-not-greaterp/fR/retR . */

  //fprintf (stderr, "..Executed replacement instruction %s\n", "!REPLACEMENT-primitive-not-greaterp/fR/retR");
  //fprintf (stderr, "..Executed instruction %s\n", "!REPLACEMENT-primitive-not-greaterp/fR/retR");
//#endif // #if 0
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
#ifdef JITTER_REPLICATE
  {
    /* Advance the instruction pointer, if any, to skip every
       residual but the last; branch back to replicated
       code. */
    const void *_jitter_back_to_replicated_code_pointer =
      JITTER_ARGP1;
    JITTER_SKIP_RESIDUALS_;
    goto * _jitter_back_to_replicated_code_pointer;
  }
#endif // #ifdef JITTER_REPLICATE

    /* Undefine the !REPLACEMENT-primitive-not-greaterp/fR/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#ifndef JITTER_REPLICATE
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-primitive-not-greaterp/fR/retR, _eREPLACEMENT_mprimitive_mnot_mgreaterp__fR__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#endif // #ifndef JITTER_REPLICATE
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for !REPLACEMENT-primitive-not-greaterp/fR/retR, which started with its
       definitions. */
  }
#endif // #if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
/*  End of !REPLACEMENT-primitive-not-greaterp/fR/retR , a replacement specialised instruction */

  /* Ordinary specialised instruction !REPLACEMENT-primitive-not-lessp/fR/retR (replacement) */
  /* Omit this specialised instruction altogether unless
     replacements are in fact supported in this
     configuration. */
#if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
  JITTER_INSTRUCTION_PROLOG_(!REPLACEMENT-primitive-not-lessp/fR/retR, _eREPLACEMENT_mprimitive_mnot_mlessp__fR__retR, cold)
  { /* This block begins with definitions for !REPLACEMENT-primitive-not-lessp/fR/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       312
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         !REPLACEMENT-primitive-not-lessp/fR/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "primitive-not-lessp"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "!REPLACEMENT-primitive-not-lessp/fR/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _eREPLACEMENT_mprimitive_mnot_mlessp__fR__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST JITTER_BRANCH
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 2

  /* Define argument-access macros for !REPLACEMENT-primitive-not-lessp/fR/retR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
    /* The 0th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* When jumping to the non-relocatable part it is important not
   to use a fallback version of JITTER_COMPUTED_GOTO, in order to
   prevent GCC from tail-merging. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
    /* Jump to non-relocatable code. */
    JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);

    /* Here the residual arity is given as zero: it's too late to
       skip residuals, since we've already jumped and this code is
       unreachable.  The instruction pointer, if any, is advanced
       in the non-relocatable code. */
    JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-primitive-not-lessp/fR/retR, _eREPLACEMENT_mprimitive_mnot_mlessp__fR__retR, 0)

    /* Relocated code will jump to this label in non-relocated code. */
  JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
    JITTER_COMMENT_IN_ASM_("!REPLACEMENT-primitive-not-lessp/fR/retR non-relocatable code");
#endif // #ifdef JITTER_REPLICATE
#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of !REPLACEMENT-primitive-not-lessp/fR/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  no. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
//#if 0
  //fprintf (stderr, "Executing instruction %s..\n", "!REPLACEMENT-primitive-not-lessp/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing replacement instruction %s..\n", "!REPLACEMENT-primitive-not-lessp/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing non-relocatable instruction %s with JITTER_SPECIALIZED_INSTRUCTION_WORD_NO=%i..\n", "!REPLACEMENT-primitive-not-lessp/fR/retR", (int) JITTER_SPECIALIZED_INSTRUCTION_WORD_NO); fflush (stderr);
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#undef JITTER_THIS_IS_A_REPLACEMENT
#define JITTER_THIS_IS_A_REPLACEMENT 1

    /* User code for !REPLACEMENT-primitive-not-lessp/fR/retR . */
  {
/* User-specified code, user code block part: beginning. */

    JITTERLISPVM_CHECK_TYPES_2(FIXNUM, FIXNUM, JITTER_ARGF0);
    JITTERLISP_NOTLESSP_(JITTER_TOP_MAINSTACK(),
                         JITTER_UNDER_TOP_MAINSTACK(), JITTER_TOP_MAINSTACK());
    JITTER_NIP_MAINSTACK();
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for !REPLACEMENT-primitive-not-lessp/fR/retR . */

  //fprintf (stderr, "..Executed replacement instruction %s\n", "!REPLACEMENT-primitive-not-lessp/fR/retR");
  //fprintf (stderr, "..Executed instruction %s\n", "!REPLACEMENT-primitive-not-lessp/fR/retR");
//#endif // #if 0
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
#ifdef JITTER_REPLICATE
  {
    /* Advance the instruction pointer, if any, to skip every
       residual but the last; branch back to replicated
       code. */
    const void *_jitter_back_to_replicated_code_pointer =
      JITTER_ARGP1;
    JITTER_SKIP_RESIDUALS_;
    goto * _jitter_back_to_replicated_code_pointer;
  }
#endif // #ifdef JITTER_REPLICATE

    /* Undefine the !REPLACEMENT-primitive-not-lessp/fR/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#ifndef JITTER_REPLICATE
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-primitive-not-lessp/fR/retR, _eREPLACEMENT_mprimitive_mnot_mlessp__fR__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#endif // #ifndef JITTER_REPLICATE
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for !REPLACEMENT-primitive-not-lessp/fR/retR, which started with its
       definitions. */
  }
#endif // #if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
/*  End of !REPLACEMENT-primitive-not-lessp/fR/retR , a replacement specialised instruction */

  /* Ordinary specialised instruction !REPLACEMENT-primitive-one-minus/fR/retR (replacement) */
  /* Omit this specialised instruction altogether unless
     replacements are in fact supported in this
     configuration. */
#if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
  JITTER_INSTRUCTION_PROLOG_(!REPLACEMENT-primitive-one-minus/fR/retR, _eREPLACEMENT_mprimitive_mone_mminus__fR__retR, cold)
  { /* This block begins with definitions for !REPLACEMENT-primitive-one-minus/fR/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       313
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         !REPLACEMENT-primitive-one-minus/fR/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "primitive-one-minus"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "!REPLACEMENT-primitive-one-minus/fR/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _eREPLACEMENT_mprimitive_mone_mminus__fR__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST JITTER_BRANCH
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 2

  /* Define argument-access macros for !REPLACEMENT-primitive-one-minus/fR/retR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
    /* The 0th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* When jumping to the non-relocatable part it is important not
   to use a fallback version of JITTER_COMPUTED_GOTO, in order to
   prevent GCC from tail-merging. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
    /* Jump to non-relocatable code. */
    JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);

    /* Here the residual arity is given as zero: it's too late to
       skip residuals, since we've already jumped and this code is
       unreachable.  The instruction pointer, if any, is advanced
       in the non-relocatable code. */
    JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-primitive-one-minus/fR/retR, _eREPLACEMENT_mprimitive_mone_mminus__fR__retR, 0)

    /* Relocated code will jump to this label in non-relocated code. */
  JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
    JITTER_COMMENT_IN_ASM_("!REPLACEMENT-primitive-one-minus/fR/retR non-relocatable code");
#endif // #ifdef JITTER_REPLICATE
#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of !REPLACEMENT-primitive-one-minus/fR/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  no. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
//#if 0
  //fprintf (stderr, "Executing instruction %s..\n", "!REPLACEMENT-primitive-one-minus/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing replacement instruction %s..\n", "!REPLACEMENT-primitive-one-minus/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing non-relocatable instruction %s with JITTER_SPECIALIZED_INSTRUCTION_WORD_NO=%i..\n", "!REPLACEMENT-primitive-one-minus/fR/retR", (int) JITTER_SPECIALIZED_INSTRUCTION_WORD_NO); fflush (stderr);
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#undef JITTER_THIS_IS_A_REPLACEMENT
#define JITTER_THIS_IS_A_REPLACEMENT 1

    /* User code for !REPLACEMENT-primitive-one-minus/fR/retR . */
  {
/* User-specified code, user code block part: beginning. */

    JITTERLISPVM_CHECK_TYPES_1(FIXNUM, JITTER_ARGF0);
    JITTERLISP_1MINUS_OR_OVERFLOW_(JITTER_TOP_MAINSTACK(),
                                   JITTER_TOP_MAINSTACK(),
                                   JITTER_ARGF0);
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for !REPLACEMENT-primitive-one-minus/fR/retR . */

  //fprintf (stderr, "..Executed replacement instruction %s\n", "!REPLACEMENT-primitive-one-minus/fR/retR");
  //fprintf (stderr, "..Executed instruction %s\n", "!REPLACEMENT-primitive-one-minus/fR/retR");
//#endif // #if 0
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
#ifdef JITTER_REPLICATE
  {
    /* Advance the instruction pointer, if any, to skip every
       residual but the last; branch back to replicated
       code. */
    const void *_jitter_back_to_replicated_code_pointer =
      JITTER_ARGP1;
    JITTER_SKIP_RESIDUALS_;
    goto * _jitter_back_to_replicated_code_pointer;
  }
#endif // #ifdef JITTER_REPLICATE

    /* Undefine the !REPLACEMENT-primitive-one-minus/fR/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#ifndef JITTER_REPLICATE
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-primitive-one-minus/fR/retR, _eREPLACEMENT_mprimitive_mone_mminus__fR__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#endif // #ifndef JITTER_REPLICATE
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for !REPLACEMENT-primitive-one-minus/fR/retR, which started with its
       definitions. */
  }
#endif // #if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
/*  End of !REPLACEMENT-primitive-one-minus/fR/retR , a replacement specialised instruction */

  /* Ordinary specialised instruction !REPLACEMENT-primitive-one-plus/fR/retR (replacement) */
  /* Omit this specialised instruction altogether unless
     replacements are in fact supported in this
     configuration. */
#if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
  JITTER_INSTRUCTION_PROLOG_(!REPLACEMENT-primitive-one-plus/fR/retR, _eREPLACEMENT_mprimitive_mone_mplus__fR__retR, cold)
  { /* This block begins with definitions for !REPLACEMENT-primitive-one-plus/fR/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       314
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         !REPLACEMENT-primitive-one-plus/fR/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "primitive-one-plus"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "!REPLACEMENT-primitive-one-plus/fR/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _eREPLACEMENT_mprimitive_mone_mplus__fR__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST JITTER_BRANCH
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 2

  /* Define argument-access macros for !REPLACEMENT-primitive-one-plus/fR/retR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
    /* The 0th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* When jumping to the non-relocatable part it is important not
   to use a fallback version of JITTER_COMPUTED_GOTO, in order to
   prevent GCC from tail-merging. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
    /* Jump to non-relocatable code. */
    JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);

    /* Here the residual arity is given as zero: it's too late to
       skip residuals, since we've already jumped and this code is
       unreachable.  The instruction pointer, if any, is advanced
       in the non-relocatable code. */
    JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-primitive-one-plus/fR/retR, _eREPLACEMENT_mprimitive_mone_mplus__fR__retR, 0)

    /* Relocated code will jump to this label in non-relocated code. */
  JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
    JITTER_COMMENT_IN_ASM_("!REPLACEMENT-primitive-one-plus/fR/retR non-relocatable code");
#endif // #ifdef JITTER_REPLICATE
#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of !REPLACEMENT-primitive-one-plus/fR/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  no. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
//#if 0
  //fprintf (stderr, "Executing instruction %s..\n", "!REPLACEMENT-primitive-one-plus/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing replacement instruction %s..\n", "!REPLACEMENT-primitive-one-plus/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing non-relocatable instruction %s with JITTER_SPECIALIZED_INSTRUCTION_WORD_NO=%i..\n", "!REPLACEMENT-primitive-one-plus/fR/retR", (int) JITTER_SPECIALIZED_INSTRUCTION_WORD_NO); fflush (stderr);
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#undef JITTER_THIS_IS_A_REPLACEMENT
#define JITTER_THIS_IS_A_REPLACEMENT 1

    /* User code for !REPLACEMENT-primitive-one-plus/fR/retR . */
  {
/* User-specified code, user code block part: beginning. */

    JITTERLISPVM_CHECK_TYPES_1(FIXNUM, JITTER_ARGF0);
    JITTERLISP_1PLUS_OR_OVERFLOW_(JITTER_TOP_MAINSTACK(),
                                  JITTER_TOP_MAINSTACK(),
                                  JITTER_ARGF0);
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for !REPLACEMENT-primitive-one-plus/fR/retR . */

  //fprintf (stderr, "..Executed replacement instruction %s\n", "!REPLACEMENT-primitive-one-plus/fR/retR");
  //fprintf (stderr, "..Executed instruction %s\n", "!REPLACEMENT-primitive-one-plus/fR/retR");
//#endif // #if 0
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
#ifdef JITTER_REPLICATE
  {
    /* Advance the instruction pointer, if any, to skip every
       residual but the last; branch back to replicated
       code. */
    const void *_jitter_back_to_replicated_code_pointer =
      JITTER_ARGP1;
    JITTER_SKIP_RESIDUALS_;
    goto * _jitter_back_to_replicated_code_pointer;
  }
#endif // #ifdef JITTER_REPLICATE

    /* Undefine the !REPLACEMENT-primitive-one-plus/fR/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#ifndef JITTER_REPLICATE
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-primitive-one-plus/fR/retR, _eREPLACEMENT_mprimitive_mone_mplus__fR__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#endif // #ifndef JITTER_REPLICATE
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for !REPLACEMENT-primitive-one-plus/fR/retR, which started with its
       definitions. */
  }
#endif // #if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
/*  End of !REPLACEMENT-primitive-one-plus/fR/retR , a replacement specialised instruction */

  /* Ordinary specialised instruction !REPLACEMENT-primitive-positivep/fR/retR (replacement) */
  /* Omit this specialised instruction altogether unless
     replacements are in fact supported in this
     configuration. */
#if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
  JITTER_INSTRUCTION_PROLOG_(!REPLACEMENT-primitive-positivep/fR/retR, _eREPLACEMENT_mprimitive_mpositivep__fR__retR, cold)
  { /* This block begins with definitions for !REPLACEMENT-primitive-positivep/fR/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       315
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         !REPLACEMENT-primitive-positivep/fR/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "primitive-positivep"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "!REPLACEMENT-primitive-positivep/fR/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _eREPLACEMENT_mprimitive_mpositivep__fR__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST JITTER_BRANCH
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 2

  /* Define argument-access macros for !REPLACEMENT-primitive-positivep/fR/retR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
    /* The 0th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* When jumping to the non-relocatable part it is important not
   to use a fallback version of JITTER_COMPUTED_GOTO, in order to
   prevent GCC from tail-merging. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
    /* Jump to non-relocatable code. */
    JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);

    /* Here the residual arity is given as zero: it's too late to
       skip residuals, since we've already jumped and this code is
       unreachable.  The instruction pointer, if any, is advanced
       in the non-relocatable code. */
    JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-primitive-positivep/fR/retR, _eREPLACEMENT_mprimitive_mpositivep__fR__retR, 0)

    /* Relocated code will jump to this label in non-relocated code. */
  JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
    JITTER_COMMENT_IN_ASM_("!REPLACEMENT-primitive-positivep/fR/retR non-relocatable code");
#endif // #ifdef JITTER_REPLICATE
#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of !REPLACEMENT-primitive-positivep/fR/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  no. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
//#if 0
  //fprintf (stderr, "Executing instruction %s..\n", "!REPLACEMENT-primitive-positivep/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing replacement instruction %s..\n", "!REPLACEMENT-primitive-positivep/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing non-relocatable instruction %s with JITTER_SPECIALIZED_INSTRUCTION_WORD_NO=%i..\n", "!REPLACEMENT-primitive-positivep/fR/retR", (int) JITTER_SPECIALIZED_INSTRUCTION_WORD_NO); fflush (stderr);
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#undef JITTER_THIS_IS_A_REPLACEMENT
#define JITTER_THIS_IS_A_REPLACEMENT 1

    /* User code for !REPLACEMENT-primitive-positivep/fR/retR . */
  {
/* User-specified code, user code block part: beginning. */

    JITTERLISPVM_CHECK_TYPES_1(FIXNUM, JITTER_ARGF0);
    JITTERLISP_POSITIVEP_(JITTER_TOP_MAINSTACK(), JITTER_TOP_MAINSTACK());
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for !REPLACEMENT-primitive-positivep/fR/retR . */

  //fprintf (stderr, "..Executed replacement instruction %s\n", "!REPLACEMENT-primitive-positivep/fR/retR");
  //fprintf (stderr, "..Executed instruction %s\n", "!REPLACEMENT-primitive-positivep/fR/retR");
//#endif // #if 0
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
#ifdef JITTER_REPLICATE
  {
    /* Advance the instruction pointer, if any, to skip every
       residual but the last; branch back to replicated
       code. */
    const void *_jitter_back_to_replicated_code_pointer =
      JITTER_ARGP1;
    JITTER_SKIP_RESIDUALS_;
    goto * _jitter_back_to_replicated_code_pointer;
  }
#endif // #ifdef JITTER_REPLICATE

    /* Undefine the !REPLACEMENT-primitive-positivep/fR/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#ifndef JITTER_REPLICATE
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-primitive-positivep/fR/retR, _eREPLACEMENT_mprimitive_mpositivep__fR__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#endif // #ifndef JITTER_REPLICATE
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for !REPLACEMENT-primitive-positivep/fR/retR, which started with its
       definitions. */
  }
#endif // #if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
/*  End of !REPLACEMENT-primitive-positivep/fR/retR , a replacement specialised instruction */

  /* Ordinary specialised instruction !REPLACEMENT-primitive-primordial-divided/fR/retR (replacement) */
  /* Omit this specialised instruction altogether unless
     replacements are in fact supported in this
     configuration. */
#if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
  JITTER_INSTRUCTION_PROLOG_(!REPLACEMENT-primitive-primordial-divided/fR/retR, _eREPLACEMENT_mprimitive_mprimordial_mdivided__fR__retR, cold)
  { /* This block begins with definitions for !REPLACEMENT-primitive-primordial-divided/fR/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       316
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         !REPLACEMENT-primitive-primordial-divided/fR/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "primitive-primordial-divided"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "!REPLACEMENT-primitive-primordial-divided/fR/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _eREPLACEMENT_mprimitive_mprimordial_mdivided__fR__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST JITTER_BRANCH
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 2

  /* Define argument-access macros for !REPLACEMENT-primitive-primordial-divided/fR/retR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
    /* The 0th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* When jumping to the non-relocatable part it is important not
   to use a fallback version of JITTER_COMPUTED_GOTO, in order to
   prevent GCC from tail-merging. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
    /* Jump to non-relocatable code. */
    JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);

    /* Here the residual arity is given as zero: it's too late to
       skip residuals, since we've already jumped and this code is
       unreachable.  The instruction pointer, if any, is advanced
       in the non-relocatable code. */
    JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-primitive-primordial-divided/fR/retR, _eREPLACEMENT_mprimitive_mprimordial_mdivided__fR__retR, 0)

    /* Relocated code will jump to this label in non-relocated code. */
  JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
    JITTER_COMMENT_IN_ASM_("!REPLACEMENT-primitive-primordial-divided/fR/retR non-relocatable code");
#endif // #ifdef JITTER_REPLICATE
#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of !REPLACEMENT-primitive-primordial-divided/fR/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  no. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
//#if 0
  //fprintf (stderr, "Executing instruction %s..\n", "!REPLACEMENT-primitive-primordial-divided/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing replacement instruction %s..\n", "!REPLACEMENT-primitive-primordial-divided/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing non-relocatable instruction %s with JITTER_SPECIALIZED_INSTRUCTION_WORD_NO=%i..\n", "!REPLACEMENT-primitive-primordial-divided/fR/retR", (int) JITTER_SPECIALIZED_INSTRUCTION_WORD_NO); fflush (stderr);
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#undef JITTER_THIS_IS_A_REPLACEMENT
#define JITTER_THIS_IS_A_REPLACEMENT 1

    /* User code for !REPLACEMENT-primitive-primordial-divided/fR/retR . */
  {
/* User-specified code, user code block part: beginning. */

    JITTERLISPVM_CHECK_TYPES_2(FIXNUM, FIXNUM, JITTER_ARGF0);
    JITTERLISP_DIVIDED_OR_OVERFLOW_(JITTER_TOP_MAINSTACK(),
                                    JITTER_UNDER_TOP_MAINSTACK(),
                                    JITTER_TOP_MAINSTACK(),
                                    JITTER_ARGF0);
    JITTER_NIP_MAINSTACK();
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for !REPLACEMENT-primitive-primordial-divided/fR/retR . */

  //fprintf (stderr, "..Executed replacement instruction %s\n", "!REPLACEMENT-primitive-primordial-divided/fR/retR");
  //fprintf (stderr, "..Executed instruction %s\n", "!REPLACEMENT-primitive-primordial-divided/fR/retR");
//#endif // #if 0
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
#ifdef JITTER_REPLICATE
  {
    /* Advance the instruction pointer, if any, to skip every
       residual but the last; branch back to replicated
       code. */
    const void *_jitter_back_to_replicated_code_pointer =
      JITTER_ARGP1;
    JITTER_SKIP_RESIDUALS_;
    goto * _jitter_back_to_replicated_code_pointer;
  }
#endif // #ifdef JITTER_REPLICATE

    /* Undefine the !REPLACEMENT-primitive-primordial-divided/fR/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#ifndef JITTER_REPLICATE
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-primitive-primordial-divided/fR/retR, _eREPLACEMENT_mprimitive_mprimordial_mdivided__fR__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#endif // #ifndef JITTER_REPLICATE
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for !REPLACEMENT-primitive-primordial-divided/fR/retR, which started with its
       definitions. */
  }
#endif // #if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
/*  End of !REPLACEMENT-primitive-primordial-divided/fR/retR , a replacement specialised instruction */

  /* Ordinary specialised instruction !REPLACEMENT-primitive-primordial-divided-unsafe/fR/retR (replacement) */
  /* Omit this specialised instruction altogether unless
     replacements are in fact supported in this
     configuration. */
#if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
  JITTER_INSTRUCTION_PROLOG_(!REPLACEMENT-primitive-primordial-divided-unsafe/fR/retR, _eREPLACEMENT_mprimitive_mprimordial_mdivided_munsafe__fR__retR, cold)
  { /* This block begins with definitions for !REPLACEMENT-primitive-primordial-divided-unsafe/fR/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       317
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         !REPLACEMENT-primitive-primordial-divided-unsafe/fR/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "primitive-primordial-divided-unsafe"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "!REPLACEMENT-primitive-primordial-divided-unsafe/fR/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _eREPLACEMENT_mprimitive_mprimordial_mdivided_munsafe__fR__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST JITTER_BRANCH
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 2

  /* Define argument-access macros for !REPLACEMENT-primitive-primordial-divided-unsafe/fR/retR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
    /* The 0th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* When jumping to the non-relocatable part it is important not
   to use a fallback version of JITTER_COMPUTED_GOTO, in order to
   prevent GCC from tail-merging. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
    /* Jump to non-relocatable code. */
    JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);

    /* Here the residual arity is given as zero: it's too late to
       skip residuals, since we've already jumped and this code is
       unreachable.  The instruction pointer, if any, is advanced
       in the non-relocatable code. */
    JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-primitive-primordial-divided-unsafe/fR/retR, _eREPLACEMENT_mprimitive_mprimordial_mdivided_munsafe__fR__retR, 0)

    /* Relocated code will jump to this label in non-relocated code. */
  JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
    JITTER_COMMENT_IN_ASM_("!REPLACEMENT-primitive-primordial-divided-unsafe/fR/retR non-relocatable code");
#endif // #ifdef JITTER_REPLICATE
#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of !REPLACEMENT-primitive-primordial-divided-unsafe/fR/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  no. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
//#if 0
  //fprintf (stderr, "Executing instruction %s..\n", "!REPLACEMENT-primitive-primordial-divided-unsafe/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing replacement instruction %s..\n", "!REPLACEMENT-primitive-primordial-divided-unsafe/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing non-relocatable instruction %s with JITTER_SPECIALIZED_INSTRUCTION_WORD_NO=%i..\n", "!REPLACEMENT-primitive-primordial-divided-unsafe/fR/retR", (int) JITTER_SPECIALIZED_INSTRUCTION_WORD_NO); fflush (stderr);
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#undef JITTER_THIS_IS_A_REPLACEMENT
#define JITTER_THIS_IS_A_REPLACEMENT 1

    /* User code for !REPLACEMENT-primitive-primordial-divided-unsafe/fR/retR . */
  {
/* User-specified code, user code block part: beginning. */

    /* The second argument has already been validated if we are using this. */
    JITTERLISPVM_CHECK_TYPES_2(FIXNUM, ANYTHING, JITTER_ARGF0);
    JITTERLISP_DIVIDED_UNSAFE_(JITTER_TOP_MAINSTACK(),
                               JITTER_UNDER_TOP_MAINSTACK(),
                               JITTER_TOP_MAINSTACK());
    JITTER_NIP_MAINSTACK();
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for !REPLACEMENT-primitive-primordial-divided-unsafe/fR/retR . */

  //fprintf (stderr, "..Executed replacement instruction %s\n", "!REPLACEMENT-primitive-primordial-divided-unsafe/fR/retR");
  //fprintf (stderr, "..Executed instruction %s\n", "!REPLACEMENT-primitive-primordial-divided-unsafe/fR/retR");
//#endif // #if 0
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
#ifdef JITTER_REPLICATE
  {
    /* Advance the instruction pointer, if any, to skip every
       residual but the last; branch back to replicated
       code. */
    const void *_jitter_back_to_replicated_code_pointer =
      JITTER_ARGP1;
    JITTER_SKIP_RESIDUALS_;
    goto * _jitter_back_to_replicated_code_pointer;
  }
#endif // #ifdef JITTER_REPLICATE

    /* Undefine the !REPLACEMENT-primitive-primordial-divided-unsafe/fR/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#ifndef JITTER_REPLICATE
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-primitive-primordial-divided-unsafe/fR/retR, _eREPLACEMENT_mprimitive_mprimordial_mdivided_munsafe__fR__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#endif // #ifndef JITTER_REPLICATE
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for !REPLACEMENT-primitive-primordial-divided-unsafe/fR/retR, which started with its
       definitions. */
  }
#endif // #if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
/*  End of !REPLACEMENT-primitive-primordial-divided-unsafe/fR/retR , a replacement specialised instruction */

  /* Ordinary specialised instruction !REPLACEMENT-primitive-primordial-minus/fR/retR (replacement) */
  /* Omit this specialised instruction altogether unless
     replacements are in fact supported in this
     configuration. */
#if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
  JITTER_INSTRUCTION_PROLOG_(!REPLACEMENT-primitive-primordial-minus/fR/retR, _eREPLACEMENT_mprimitive_mprimordial_mminus__fR__retR, cold)
  { /* This block begins with definitions for !REPLACEMENT-primitive-primordial-minus/fR/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       318
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         !REPLACEMENT-primitive-primordial-minus/fR/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "primitive-primordial-minus"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "!REPLACEMENT-primitive-primordial-minus/fR/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _eREPLACEMENT_mprimitive_mprimordial_mminus__fR__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST JITTER_BRANCH
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 2

  /* Define argument-access macros for !REPLACEMENT-primitive-primordial-minus/fR/retR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
    /* The 0th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* When jumping to the non-relocatable part it is important not
   to use a fallback version of JITTER_COMPUTED_GOTO, in order to
   prevent GCC from tail-merging. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
    /* Jump to non-relocatable code. */
    JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);

    /* Here the residual arity is given as zero: it's too late to
       skip residuals, since we've already jumped and this code is
       unreachable.  The instruction pointer, if any, is advanced
       in the non-relocatable code. */
    JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-primitive-primordial-minus/fR/retR, _eREPLACEMENT_mprimitive_mprimordial_mminus__fR__retR, 0)

    /* Relocated code will jump to this label in non-relocated code. */
  JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
    JITTER_COMMENT_IN_ASM_("!REPLACEMENT-primitive-primordial-minus/fR/retR non-relocatable code");
#endif // #ifdef JITTER_REPLICATE
#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of !REPLACEMENT-primitive-primordial-minus/fR/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  no. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
//#if 0
  //fprintf (stderr, "Executing instruction %s..\n", "!REPLACEMENT-primitive-primordial-minus/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing replacement instruction %s..\n", "!REPLACEMENT-primitive-primordial-minus/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing non-relocatable instruction %s with JITTER_SPECIALIZED_INSTRUCTION_WORD_NO=%i..\n", "!REPLACEMENT-primitive-primordial-minus/fR/retR", (int) JITTER_SPECIALIZED_INSTRUCTION_WORD_NO); fflush (stderr);
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#undef JITTER_THIS_IS_A_REPLACEMENT
#define JITTER_THIS_IS_A_REPLACEMENT 1

    /* User code for !REPLACEMENT-primitive-primordial-minus/fR/retR . */
  {
/* User-specified code, user code block part: beginning. */

    JITTERLISPVM_CHECK_TYPES_2(FIXNUM, FIXNUM, JITTER_ARGF0);
    JITTERLISP_MINUS_OR_OVERFLOW_(JITTER_TOP_MAINSTACK(),
                                  JITTER_UNDER_TOP_MAINSTACK(),
                                  JITTER_TOP_MAINSTACK(),
                                  JITTER_ARGF0);
    JITTER_NIP_MAINSTACK();
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for !REPLACEMENT-primitive-primordial-minus/fR/retR . */

  //fprintf (stderr, "..Executed replacement instruction %s\n", "!REPLACEMENT-primitive-primordial-minus/fR/retR");
  //fprintf (stderr, "..Executed instruction %s\n", "!REPLACEMENT-primitive-primordial-minus/fR/retR");
//#endif // #if 0
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
#ifdef JITTER_REPLICATE
  {
    /* Advance the instruction pointer, if any, to skip every
       residual but the last; branch back to replicated
       code. */
    const void *_jitter_back_to_replicated_code_pointer =
      JITTER_ARGP1;
    JITTER_SKIP_RESIDUALS_;
    goto * _jitter_back_to_replicated_code_pointer;
  }
#endif // #ifdef JITTER_REPLICATE

    /* Undefine the !REPLACEMENT-primitive-primordial-minus/fR/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#ifndef JITTER_REPLICATE
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-primitive-primordial-minus/fR/retR, _eREPLACEMENT_mprimitive_mprimordial_mminus__fR__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#endif // #ifndef JITTER_REPLICATE
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for !REPLACEMENT-primitive-primordial-minus/fR/retR, which started with its
       definitions. */
  }
#endif // #if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
/*  End of !REPLACEMENT-primitive-primordial-minus/fR/retR , a replacement specialised instruction */

  /* Ordinary specialised instruction !REPLACEMENT-primitive-primordial-plus/fR/retR (replacement) */
  /* Omit this specialised instruction altogether unless
     replacements are in fact supported in this
     configuration. */
#if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
  JITTER_INSTRUCTION_PROLOG_(!REPLACEMENT-primitive-primordial-plus/fR/retR, _eREPLACEMENT_mprimitive_mprimordial_mplus__fR__retR, cold)
  { /* This block begins with definitions for !REPLACEMENT-primitive-primordial-plus/fR/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       319
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         !REPLACEMENT-primitive-primordial-plus/fR/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "primitive-primordial-plus"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "!REPLACEMENT-primitive-primordial-plus/fR/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _eREPLACEMENT_mprimitive_mprimordial_mplus__fR__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST JITTER_BRANCH
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 2

  /* Define argument-access macros for !REPLACEMENT-primitive-primordial-plus/fR/retR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
    /* The 0th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* When jumping to the non-relocatable part it is important not
   to use a fallback version of JITTER_COMPUTED_GOTO, in order to
   prevent GCC from tail-merging. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
    /* Jump to non-relocatable code. */
    JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);

    /* Here the residual arity is given as zero: it's too late to
       skip residuals, since we've already jumped and this code is
       unreachable.  The instruction pointer, if any, is advanced
       in the non-relocatable code. */
    JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-primitive-primordial-plus/fR/retR, _eREPLACEMENT_mprimitive_mprimordial_mplus__fR__retR, 0)

    /* Relocated code will jump to this label in non-relocated code. */
  JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
    JITTER_COMMENT_IN_ASM_("!REPLACEMENT-primitive-primordial-plus/fR/retR non-relocatable code");
#endif // #ifdef JITTER_REPLICATE
#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of !REPLACEMENT-primitive-primordial-plus/fR/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  no. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
//#if 0
  //fprintf (stderr, "Executing instruction %s..\n", "!REPLACEMENT-primitive-primordial-plus/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing replacement instruction %s..\n", "!REPLACEMENT-primitive-primordial-plus/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing non-relocatable instruction %s with JITTER_SPECIALIZED_INSTRUCTION_WORD_NO=%i..\n", "!REPLACEMENT-primitive-primordial-plus/fR/retR", (int) JITTER_SPECIALIZED_INSTRUCTION_WORD_NO); fflush (stderr);
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#undef JITTER_THIS_IS_A_REPLACEMENT
#define JITTER_THIS_IS_A_REPLACEMENT 1

    /* User code for !REPLACEMENT-primitive-primordial-plus/fR/retR . */
  {
/* User-specified code, user code block part: beginning. */

    JITTERLISPVM_CHECK_TYPES_2(FIXNUM, FIXNUM, JITTER_ARGF0);
    JITTERLISP_PLUS_OR_OVERFLOW_(JITTER_TOP_MAINSTACK(),
                                 JITTER_UNDER_TOP_MAINSTACK(),
                                 JITTER_TOP_MAINSTACK(),
                                 JITTER_ARGF0);
    JITTER_NIP_MAINSTACK();
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for !REPLACEMENT-primitive-primordial-plus/fR/retR . */

  //fprintf (stderr, "..Executed replacement instruction %s\n", "!REPLACEMENT-primitive-primordial-plus/fR/retR");
  //fprintf (stderr, "..Executed instruction %s\n", "!REPLACEMENT-primitive-primordial-plus/fR/retR");
//#endif // #if 0
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
#ifdef JITTER_REPLICATE
  {
    /* Advance the instruction pointer, if any, to skip every
       residual but the last; branch back to replicated
       code. */
    const void *_jitter_back_to_replicated_code_pointer =
      JITTER_ARGP1;
    JITTER_SKIP_RESIDUALS_;
    goto * _jitter_back_to_replicated_code_pointer;
  }
#endif // #ifdef JITTER_REPLICATE

    /* Undefine the !REPLACEMENT-primitive-primordial-plus/fR/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#ifndef JITTER_REPLICATE
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-primitive-primordial-plus/fR/retR, _eREPLACEMENT_mprimitive_mprimordial_mplus__fR__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#endif // #ifndef JITTER_REPLICATE
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for !REPLACEMENT-primitive-primordial-plus/fR/retR, which started with its
       definitions. */
  }
#endif // #if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
/*  End of !REPLACEMENT-primitive-primordial-plus/fR/retR , a replacement specialised instruction */

  /* Ordinary specialised instruction !REPLACEMENT-primitive-primordial-times/fR/retR (replacement) */
  /* Omit this specialised instruction altogether unless
     replacements are in fact supported in this
     configuration. */
#if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
  JITTER_INSTRUCTION_PROLOG_(!REPLACEMENT-primitive-primordial-times/fR/retR, _eREPLACEMENT_mprimitive_mprimordial_mtimes__fR__retR, cold)
  { /* This block begins with definitions for !REPLACEMENT-primitive-primordial-times/fR/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       320
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         !REPLACEMENT-primitive-primordial-times/fR/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "primitive-primordial-times"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "!REPLACEMENT-primitive-primordial-times/fR/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _eREPLACEMENT_mprimitive_mprimordial_mtimes__fR__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST JITTER_BRANCH
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 2

  /* Define argument-access macros for !REPLACEMENT-primitive-primordial-times/fR/retR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
    /* The 0th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* When jumping to the non-relocatable part it is important not
   to use a fallback version of JITTER_COMPUTED_GOTO, in order to
   prevent GCC from tail-merging. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
    /* Jump to non-relocatable code. */
    JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);

    /* Here the residual arity is given as zero: it's too late to
       skip residuals, since we've already jumped and this code is
       unreachable.  The instruction pointer, if any, is advanced
       in the non-relocatable code. */
    JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-primitive-primordial-times/fR/retR, _eREPLACEMENT_mprimitive_mprimordial_mtimes__fR__retR, 0)

    /* Relocated code will jump to this label in non-relocated code. */
  JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
    JITTER_COMMENT_IN_ASM_("!REPLACEMENT-primitive-primordial-times/fR/retR non-relocatable code");
#endif // #ifdef JITTER_REPLICATE
#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of !REPLACEMENT-primitive-primordial-times/fR/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  no. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
//#if 0
  //fprintf (stderr, "Executing instruction %s..\n", "!REPLACEMENT-primitive-primordial-times/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing replacement instruction %s..\n", "!REPLACEMENT-primitive-primordial-times/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing non-relocatable instruction %s with JITTER_SPECIALIZED_INSTRUCTION_WORD_NO=%i..\n", "!REPLACEMENT-primitive-primordial-times/fR/retR", (int) JITTER_SPECIALIZED_INSTRUCTION_WORD_NO); fflush (stderr);
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#undef JITTER_THIS_IS_A_REPLACEMENT
#define JITTER_THIS_IS_A_REPLACEMENT 1

    /* User code for !REPLACEMENT-primitive-primordial-times/fR/retR . */
  {
/* User-specified code, user code block part: beginning. */

    JITTERLISPVM_CHECK_TYPES_2(FIXNUM, FIXNUM, JITTER_ARGF0);
    JITTERLISP_TIMES_OR_OVERFLOW_(JITTER_TOP_MAINSTACK(),
                                  JITTER_UNDER_TOP_MAINSTACK(),
                                  JITTER_TOP_MAINSTACK(),
                                  JITTER_ARGF0);
    JITTER_NIP_MAINSTACK();
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for !REPLACEMENT-primitive-primordial-times/fR/retR . */

  //fprintf (stderr, "..Executed replacement instruction %s\n", "!REPLACEMENT-primitive-primordial-times/fR/retR");
  //fprintf (stderr, "..Executed instruction %s\n", "!REPLACEMENT-primitive-primordial-times/fR/retR");
//#endif // #if 0
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
#ifdef JITTER_REPLICATE
  {
    /* Advance the instruction pointer, if any, to skip every
       residual but the last; branch back to replicated
       code. */
    const void *_jitter_back_to_replicated_code_pointer =
      JITTER_ARGP1;
    JITTER_SKIP_RESIDUALS_;
    goto * _jitter_back_to_replicated_code_pointer;
  }
#endif // #ifdef JITTER_REPLICATE

    /* Undefine the !REPLACEMENT-primitive-primordial-times/fR/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#ifndef JITTER_REPLICATE
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-primitive-primordial-times/fR/retR, _eREPLACEMENT_mprimitive_mprimordial_mtimes__fR__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#endif // #ifndef JITTER_REPLICATE
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for !REPLACEMENT-primitive-primordial-times/fR/retR, which started with its
       definitions. */
  }
#endif // #if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
/*  End of !REPLACEMENT-primitive-primordial-times/fR/retR , a replacement specialised instruction */

  /* Ordinary specialised instruction !REPLACEMENT-primitive-quotient/fR/retR (replacement) */
  /* Omit this specialised instruction altogether unless
     replacements are in fact supported in this
     configuration. */
#if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
  JITTER_INSTRUCTION_PROLOG_(!REPLACEMENT-primitive-quotient/fR/retR, _eREPLACEMENT_mprimitive_mquotient__fR__retR, cold)
  { /* This block begins with definitions for !REPLACEMENT-primitive-quotient/fR/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       321
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         !REPLACEMENT-primitive-quotient/fR/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "primitive-quotient"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "!REPLACEMENT-primitive-quotient/fR/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _eREPLACEMENT_mprimitive_mquotient__fR__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST JITTER_BRANCH
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 2

  /* Define argument-access macros for !REPLACEMENT-primitive-quotient/fR/retR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
    /* The 0th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* When jumping to the non-relocatable part it is important not
   to use a fallback version of JITTER_COMPUTED_GOTO, in order to
   prevent GCC from tail-merging. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
    /* Jump to non-relocatable code. */
    JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);

    /* Here the residual arity is given as zero: it's too late to
       skip residuals, since we've already jumped and this code is
       unreachable.  The instruction pointer, if any, is advanced
       in the non-relocatable code. */
    JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-primitive-quotient/fR/retR, _eREPLACEMENT_mprimitive_mquotient__fR__retR, 0)

    /* Relocated code will jump to this label in non-relocated code. */
  JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
    JITTER_COMMENT_IN_ASM_("!REPLACEMENT-primitive-quotient/fR/retR non-relocatable code");
#endif // #ifdef JITTER_REPLICATE
#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of !REPLACEMENT-primitive-quotient/fR/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  no. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
//#if 0
  //fprintf (stderr, "Executing instruction %s..\n", "!REPLACEMENT-primitive-quotient/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing replacement instruction %s..\n", "!REPLACEMENT-primitive-quotient/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing non-relocatable instruction %s with JITTER_SPECIALIZED_INSTRUCTION_WORD_NO=%i..\n", "!REPLACEMENT-primitive-quotient/fR/retR", (int) JITTER_SPECIALIZED_INSTRUCTION_WORD_NO); fflush (stderr);
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#undef JITTER_THIS_IS_A_REPLACEMENT
#define JITTER_THIS_IS_A_REPLACEMENT 1

    /* User code for !REPLACEMENT-primitive-quotient/fR/retR . */
  {
/* User-specified code, user code block part: beginning. */

    JITTERLISPVM_CHECK_TYPES_2(FIXNUM, FIXNUM, JITTER_ARGF0);
    JITTERLISP_QUOTIENT_OR_OVERFLOW_(JITTER_TOP_MAINSTACK(),
                                     JITTER_UNDER_TOP_MAINSTACK(),
                                     JITTER_TOP_MAINSTACK(),
                                     JITTER_ARGF0);
    JITTER_NIP_MAINSTACK();
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for !REPLACEMENT-primitive-quotient/fR/retR . */

  //fprintf (stderr, "..Executed replacement instruction %s\n", "!REPLACEMENT-primitive-quotient/fR/retR");
  //fprintf (stderr, "..Executed instruction %s\n", "!REPLACEMENT-primitive-quotient/fR/retR");
//#endif // #if 0
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
#ifdef JITTER_REPLICATE
  {
    /* Advance the instruction pointer, if any, to skip every
       residual but the last; branch back to replicated
       code. */
    const void *_jitter_back_to_replicated_code_pointer =
      JITTER_ARGP1;
    JITTER_SKIP_RESIDUALS_;
    goto * _jitter_back_to_replicated_code_pointer;
  }
#endif // #ifdef JITTER_REPLICATE

    /* Undefine the !REPLACEMENT-primitive-quotient/fR/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#ifndef JITTER_REPLICATE
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-primitive-quotient/fR/retR, _eREPLACEMENT_mprimitive_mquotient__fR__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#endif // #ifndef JITTER_REPLICATE
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for !REPLACEMENT-primitive-quotient/fR/retR, which started with its
       definitions. */
  }
#endif // #if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
/*  End of !REPLACEMENT-primitive-quotient/fR/retR , a replacement specialised instruction */

  /* Ordinary specialised instruction !REPLACEMENT-primitive-quotient-unsafe/fR/retR (replacement) */
  /* Omit this specialised instruction altogether unless
     replacements are in fact supported in this
     configuration. */
#if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
  JITTER_INSTRUCTION_PROLOG_(!REPLACEMENT-primitive-quotient-unsafe/fR/retR, _eREPLACEMENT_mprimitive_mquotient_munsafe__fR__retR, cold)
  { /* This block begins with definitions for !REPLACEMENT-primitive-quotient-unsafe/fR/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       322
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         !REPLACEMENT-primitive-quotient-unsafe/fR/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "primitive-quotient-unsafe"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "!REPLACEMENT-primitive-quotient-unsafe/fR/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _eREPLACEMENT_mprimitive_mquotient_munsafe__fR__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST JITTER_BRANCH
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 2

  /* Define argument-access macros for !REPLACEMENT-primitive-quotient-unsafe/fR/retR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
    /* The 0th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* When jumping to the non-relocatable part it is important not
   to use a fallback version of JITTER_COMPUTED_GOTO, in order to
   prevent GCC from tail-merging. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
    /* Jump to non-relocatable code. */
    JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);

    /* Here the residual arity is given as zero: it's too late to
       skip residuals, since we've already jumped and this code is
       unreachable.  The instruction pointer, if any, is advanced
       in the non-relocatable code. */
    JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-primitive-quotient-unsafe/fR/retR, _eREPLACEMENT_mprimitive_mquotient_munsafe__fR__retR, 0)

    /* Relocated code will jump to this label in non-relocated code. */
  JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
    JITTER_COMMENT_IN_ASM_("!REPLACEMENT-primitive-quotient-unsafe/fR/retR non-relocatable code");
#endif // #ifdef JITTER_REPLICATE
#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of !REPLACEMENT-primitive-quotient-unsafe/fR/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  no. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
//#if 0
  //fprintf (stderr, "Executing instruction %s..\n", "!REPLACEMENT-primitive-quotient-unsafe/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing replacement instruction %s..\n", "!REPLACEMENT-primitive-quotient-unsafe/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing non-relocatable instruction %s with JITTER_SPECIALIZED_INSTRUCTION_WORD_NO=%i..\n", "!REPLACEMENT-primitive-quotient-unsafe/fR/retR", (int) JITTER_SPECIALIZED_INSTRUCTION_WORD_NO); fflush (stderr);
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#undef JITTER_THIS_IS_A_REPLACEMENT
#define JITTER_THIS_IS_A_REPLACEMENT 1

    /* User code for !REPLACEMENT-primitive-quotient-unsafe/fR/retR . */
  {
/* User-specified code, user code block part: beginning. */

    /* The second argument has already been validated if we are using this. */
    JITTERLISPVM_CHECK_TYPES_2(FIXNUM, ANYTHING, JITTER_ARGF0);
    JITTERLISP_QUOTIENT_UNSAFE_(JITTER_TOP_MAINSTACK(),
                               JITTER_UNDER_TOP_MAINSTACK(),
                               JITTER_TOP_MAINSTACK());
    JITTER_NIP_MAINSTACK();
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for !REPLACEMENT-primitive-quotient-unsafe/fR/retR . */

  //fprintf (stderr, "..Executed replacement instruction %s\n", "!REPLACEMENT-primitive-quotient-unsafe/fR/retR");
  //fprintf (stderr, "..Executed instruction %s\n", "!REPLACEMENT-primitive-quotient-unsafe/fR/retR");
//#endif // #if 0
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
#ifdef JITTER_REPLICATE
  {
    /* Advance the instruction pointer, if any, to skip every
       residual but the last; branch back to replicated
       code. */
    const void *_jitter_back_to_replicated_code_pointer =
      JITTER_ARGP1;
    JITTER_SKIP_RESIDUALS_;
    goto * _jitter_back_to_replicated_code_pointer;
  }
#endif // #ifdef JITTER_REPLICATE

    /* Undefine the !REPLACEMENT-primitive-quotient-unsafe/fR/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#ifndef JITTER_REPLICATE
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-primitive-quotient-unsafe/fR/retR, _eREPLACEMENT_mprimitive_mquotient_munsafe__fR__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#endif // #ifndef JITTER_REPLICATE
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for !REPLACEMENT-primitive-quotient-unsafe/fR/retR, which started with its
       definitions. */
  }
#endif // #if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
/*  End of !REPLACEMENT-primitive-quotient-unsafe/fR/retR , a replacement specialised instruction */

  /* Ordinary specialised instruction !REPLACEMENT-primitive-remainder/fR/retR (replacement) */
  /* Omit this specialised instruction altogether unless
     replacements are in fact supported in this
     configuration. */
#if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
  JITTER_INSTRUCTION_PROLOG_(!REPLACEMENT-primitive-remainder/fR/retR, _eREPLACEMENT_mprimitive_mremainder__fR__retR, cold)
  { /* This block begins with definitions for !REPLACEMENT-primitive-remainder/fR/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       323
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         !REPLACEMENT-primitive-remainder/fR/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "primitive-remainder"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "!REPLACEMENT-primitive-remainder/fR/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _eREPLACEMENT_mprimitive_mremainder__fR__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST JITTER_BRANCH
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 2

  /* Define argument-access macros for !REPLACEMENT-primitive-remainder/fR/retR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
    /* The 0th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* When jumping to the non-relocatable part it is important not
   to use a fallback version of JITTER_COMPUTED_GOTO, in order to
   prevent GCC from tail-merging. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
    /* Jump to non-relocatable code. */
    JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);

    /* Here the residual arity is given as zero: it's too late to
       skip residuals, since we've already jumped and this code is
       unreachable.  The instruction pointer, if any, is advanced
       in the non-relocatable code. */
    JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-primitive-remainder/fR/retR, _eREPLACEMENT_mprimitive_mremainder__fR__retR, 0)

    /* Relocated code will jump to this label in non-relocated code. */
  JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
    JITTER_COMMENT_IN_ASM_("!REPLACEMENT-primitive-remainder/fR/retR non-relocatable code");
#endif // #ifdef JITTER_REPLICATE
#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of !REPLACEMENT-primitive-remainder/fR/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  no. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
//#if 0
  //fprintf (stderr, "Executing instruction %s..\n", "!REPLACEMENT-primitive-remainder/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing replacement instruction %s..\n", "!REPLACEMENT-primitive-remainder/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing non-relocatable instruction %s with JITTER_SPECIALIZED_INSTRUCTION_WORD_NO=%i..\n", "!REPLACEMENT-primitive-remainder/fR/retR", (int) JITTER_SPECIALIZED_INSTRUCTION_WORD_NO); fflush (stderr);
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#undef JITTER_THIS_IS_A_REPLACEMENT
#define JITTER_THIS_IS_A_REPLACEMENT 1

    /* User code for !REPLACEMENT-primitive-remainder/fR/retR . */
  {
/* User-specified code, user code block part: beginning. */

    JITTERLISPVM_CHECK_TYPES_2(FIXNUM, FIXNUM, JITTER_ARGF0);
    JITTERLISP_REMAINDER_OR_OVERFLOW_(JITTER_TOP_MAINSTACK(),
                                      JITTER_UNDER_TOP_MAINSTACK(),
                                      JITTER_TOP_MAINSTACK(),
                                      JITTER_ARGF0);
    JITTER_NIP_MAINSTACK();
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for !REPLACEMENT-primitive-remainder/fR/retR . */

  //fprintf (stderr, "..Executed replacement instruction %s\n", "!REPLACEMENT-primitive-remainder/fR/retR");
  //fprintf (stderr, "..Executed instruction %s\n", "!REPLACEMENT-primitive-remainder/fR/retR");
//#endif // #if 0
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
#ifdef JITTER_REPLICATE
  {
    /* Advance the instruction pointer, if any, to skip every
       residual but the last; branch back to replicated
       code. */
    const void *_jitter_back_to_replicated_code_pointer =
      JITTER_ARGP1;
    JITTER_SKIP_RESIDUALS_;
    goto * _jitter_back_to_replicated_code_pointer;
  }
#endif // #ifdef JITTER_REPLICATE

    /* Undefine the !REPLACEMENT-primitive-remainder/fR/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#ifndef JITTER_REPLICATE
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-primitive-remainder/fR/retR, _eREPLACEMENT_mprimitive_mremainder__fR__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#endif // #ifndef JITTER_REPLICATE
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for !REPLACEMENT-primitive-remainder/fR/retR, which started with its
       definitions. */
  }
#endif // #if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
/*  End of !REPLACEMENT-primitive-remainder/fR/retR , a replacement specialised instruction */

  /* Ordinary specialised instruction !REPLACEMENT-primitive-remainder-unsafe/fR/retR (replacement) */
  /* Omit this specialised instruction altogether unless
     replacements are in fact supported in this
     configuration. */
#if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
  JITTER_INSTRUCTION_PROLOG_(!REPLACEMENT-primitive-remainder-unsafe/fR/retR, _eREPLACEMENT_mprimitive_mremainder_munsafe__fR__retR, cold)
  { /* This block begins with definitions for !REPLACEMENT-primitive-remainder-unsafe/fR/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       324
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         !REPLACEMENT-primitive-remainder-unsafe/fR/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "primitive-remainder-unsafe"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "!REPLACEMENT-primitive-remainder-unsafe/fR/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _eREPLACEMENT_mprimitive_mremainder_munsafe__fR__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST JITTER_BRANCH
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 2

  /* Define argument-access macros for !REPLACEMENT-primitive-remainder-unsafe/fR/retR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
    /* The 0th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* When jumping to the non-relocatable part it is important not
   to use a fallback version of JITTER_COMPUTED_GOTO, in order to
   prevent GCC from tail-merging. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
    /* Jump to non-relocatable code. */
    JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);

    /* Here the residual arity is given as zero: it's too late to
       skip residuals, since we've already jumped and this code is
       unreachable.  The instruction pointer, if any, is advanced
       in the non-relocatable code. */
    JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-primitive-remainder-unsafe/fR/retR, _eREPLACEMENT_mprimitive_mremainder_munsafe__fR__retR, 0)

    /* Relocated code will jump to this label in non-relocated code. */
  JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
    JITTER_COMMENT_IN_ASM_("!REPLACEMENT-primitive-remainder-unsafe/fR/retR non-relocatable code");
#endif // #ifdef JITTER_REPLICATE
#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of !REPLACEMENT-primitive-remainder-unsafe/fR/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  no. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
//#if 0
  //fprintf (stderr, "Executing instruction %s..\n", "!REPLACEMENT-primitive-remainder-unsafe/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing replacement instruction %s..\n", "!REPLACEMENT-primitive-remainder-unsafe/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing non-relocatable instruction %s with JITTER_SPECIALIZED_INSTRUCTION_WORD_NO=%i..\n", "!REPLACEMENT-primitive-remainder-unsafe/fR/retR", (int) JITTER_SPECIALIZED_INSTRUCTION_WORD_NO); fflush (stderr);
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#undef JITTER_THIS_IS_A_REPLACEMENT
#define JITTER_THIS_IS_A_REPLACEMENT 1

    /* User code for !REPLACEMENT-primitive-remainder-unsafe/fR/retR . */
  {
/* User-specified code, user code block part: beginning. */

    /* The second argument has already been validated if we are using this. */
    JITTERLISPVM_CHECK_TYPES_2(FIXNUM, ANYTHING, JITTER_ARGF0);
    JITTERLISP_REMAINDER_UNSAFE_(JITTER_TOP_MAINSTACK(),
                                 JITTER_UNDER_TOP_MAINSTACK(),
                                 JITTER_TOP_MAINSTACK());
    JITTER_NIP_MAINSTACK();
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for !REPLACEMENT-primitive-remainder-unsafe/fR/retR . */

  //fprintf (stderr, "..Executed replacement instruction %s\n", "!REPLACEMENT-primitive-remainder-unsafe/fR/retR");
  //fprintf (stderr, "..Executed instruction %s\n", "!REPLACEMENT-primitive-remainder-unsafe/fR/retR");
//#endif // #if 0
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
#ifdef JITTER_REPLICATE
  {
    /* Advance the instruction pointer, if any, to skip every
       residual but the last; branch back to replicated
       code. */
    const void *_jitter_back_to_replicated_code_pointer =
      JITTER_ARGP1;
    JITTER_SKIP_RESIDUALS_;
    goto * _jitter_back_to_replicated_code_pointer;
  }
#endif // #ifdef JITTER_REPLICATE

    /* Undefine the !REPLACEMENT-primitive-remainder-unsafe/fR/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#ifndef JITTER_REPLICATE
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-primitive-remainder-unsafe/fR/retR, _eREPLACEMENT_mprimitive_mremainder_munsafe__fR__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#endif // #ifndef JITTER_REPLICATE
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for !REPLACEMENT-primitive-remainder-unsafe/fR/retR, which started with its
       definitions. */
  }
#endif // #if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
/*  End of !REPLACEMENT-primitive-remainder-unsafe/fR/retR , a replacement specialised instruction */

  /* Ordinary specialised instruction !REPLACEMENT-primitive-set-carb-special/fR/retR (replacement) */
  /* Omit this specialised instruction altogether unless
     replacements are in fact supported in this
     configuration. */
#if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
  JITTER_INSTRUCTION_PROLOG_(!REPLACEMENT-primitive-set-carb-special/fR/retR, _eREPLACEMENT_mprimitive_mset_mcarb_mspecial__fR__retR, cold)
  { /* This block begins with definitions for !REPLACEMENT-primitive-set-carb-special/fR/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       325
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         !REPLACEMENT-primitive-set-carb-special/fR/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "primitive-set-carb-special"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "!REPLACEMENT-primitive-set-carb-special/fR/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _eREPLACEMENT_mprimitive_mset_mcarb_mspecial__fR__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST JITTER_BRANCH
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 2

  /* Define argument-access macros for !REPLACEMENT-primitive-set-carb-special/fR/retR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
    /* The 0th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* When jumping to the non-relocatable part it is important not
   to use a fallback version of JITTER_COMPUTED_GOTO, in order to
   prevent GCC from tail-merging. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
    /* Jump to non-relocatable code. */
    JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);

    /* Here the residual arity is given as zero: it's too late to
       skip residuals, since we've already jumped and this code is
       unreachable.  The instruction pointer, if any, is advanced
       in the non-relocatable code. */
    JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-primitive-set-carb-special/fR/retR, _eREPLACEMENT_mprimitive_mset_mcarb_mspecial__fR__retR, 0)

    /* Relocated code will jump to this label in non-relocated code. */
  JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
    JITTER_COMMENT_IN_ASM_("!REPLACEMENT-primitive-set-carb-special/fR/retR non-relocatable code");
#endif // #ifdef JITTER_REPLICATE
#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of !REPLACEMENT-primitive-set-carb-special/fR/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  no. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
//#if 0
  //fprintf (stderr, "Executing instruction %s..\n", "!REPLACEMENT-primitive-set-carb-special/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing replacement instruction %s..\n", "!REPLACEMENT-primitive-set-carb-special/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing non-relocatable instruction %s with JITTER_SPECIALIZED_INSTRUCTION_WORD_NO=%i..\n", "!REPLACEMENT-primitive-set-carb-special/fR/retR", (int) JITTER_SPECIALIZED_INSTRUCTION_WORD_NO); fflush (stderr);
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#undef JITTER_THIS_IS_A_REPLACEMENT
#define JITTER_THIS_IS_A_REPLACEMENT 1

    /* User code for !REPLACEMENT-primitive-set-carb-special/fR/retR . */
  {
/* User-specified code, user code block part: beginning. */

    JITTERLISPVM_CHECK_TYPES_2(CONS, ANYTHING, JITTER_ARGF0);
    jitterlisp_object useless __attribute__ ((unused));
    JITTERLISP_SET_CARB_(useless,
                         JITTER_UNDER_TOP_MAINSTACK(), JITTER_TOP_MAINSTACK());
    /* Leave the two operands on the stack. */
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for !REPLACEMENT-primitive-set-carb-special/fR/retR . */

  //fprintf (stderr, "..Executed replacement instruction %s\n", "!REPLACEMENT-primitive-set-carb-special/fR/retR");
  //fprintf (stderr, "..Executed instruction %s\n", "!REPLACEMENT-primitive-set-carb-special/fR/retR");
//#endif // #if 0
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
#ifdef JITTER_REPLICATE
  {
    /* Advance the instruction pointer, if any, to skip every
       residual but the last; branch back to replicated
       code. */
    const void *_jitter_back_to_replicated_code_pointer =
      JITTER_ARGP1;
    JITTER_SKIP_RESIDUALS_;
    goto * _jitter_back_to_replicated_code_pointer;
  }
#endif // #ifdef JITTER_REPLICATE

    /* Undefine the !REPLACEMENT-primitive-set-carb-special/fR/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#ifndef JITTER_REPLICATE
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-primitive-set-carb-special/fR/retR, _eREPLACEMENT_mprimitive_mset_mcarb_mspecial__fR__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#endif // #ifndef JITTER_REPLICATE
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for !REPLACEMENT-primitive-set-carb-special/fR/retR, which started with its
       definitions. */
  }
#endif // #if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
/*  End of !REPLACEMENT-primitive-set-carb-special/fR/retR , a replacement specialised instruction */

  /* Ordinary specialised instruction !REPLACEMENT-primitive-set-cdrb-special/fR/retR (replacement) */
  /* Omit this specialised instruction altogether unless
     replacements are in fact supported in this
     configuration. */
#if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
  JITTER_INSTRUCTION_PROLOG_(!REPLACEMENT-primitive-set-cdrb-special/fR/retR, _eREPLACEMENT_mprimitive_mset_mcdrb_mspecial__fR__retR, cold)
  { /* This block begins with definitions for !REPLACEMENT-primitive-set-cdrb-special/fR/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       326
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         !REPLACEMENT-primitive-set-cdrb-special/fR/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "primitive-set-cdrb-special"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "!REPLACEMENT-primitive-set-cdrb-special/fR/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _eREPLACEMENT_mprimitive_mset_mcdrb_mspecial__fR__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST JITTER_BRANCH
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 2

  /* Define argument-access macros for !REPLACEMENT-primitive-set-cdrb-special/fR/retR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
    /* The 0th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* When jumping to the non-relocatable part it is important not
   to use a fallback version of JITTER_COMPUTED_GOTO, in order to
   prevent GCC from tail-merging. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
    /* Jump to non-relocatable code. */
    JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);

    /* Here the residual arity is given as zero: it's too late to
       skip residuals, since we've already jumped and this code is
       unreachable.  The instruction pointer, if any, is advanced
       in the non-relocatable code. */
    JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-primitive-set-cdrb-special/fR/retR, _eREPLACEMENT_mprimitive_mset_mcdrb_mspecial__fR__retR, 0)

    /* Relocated code will jump to this label in non-relocated code. */
  JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
    JITTER_COMMENT_IN_ASM_("!REPLACEMENT-primitive-set-cdrb-special/fR/retR non-relocatable code");
#endif // #ifdef JITTER_REPLICATE
#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of !REPLACEMENT-primitive-set-cdrb-special/fR/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  no. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
//#if 0
  //fprintf (stderr, "Executing instruction %s..\n", "!REPLACEMENT-primitive-set-cdrb-special/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing replacement instruction %s..\n", "!REPLACEMENT-primitive-set-cdrb-special/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing non-relocatable instruction %s with JITTER_SPECIALIZED_INSTRUCTION_WORD_NO=%i..\n", "!REPLACEMENT-primitive-set-cdrb-special/fR/retR", (int) JITTER_SPECIALIZED_INSTRUCTION_WORD_NO); fflush (stderr);
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#undef JITTER_THIS_IS_A_REPLACEMENT
#define JITTER_THIS_IS_A_REPLACEMENT 1

    /* User code for !REPLACEMENT-primitive-set-cdrb-special/fR/retR . */
  {
/* User-specified code, user code block part: beginning. */

    JITTERLISPVM_CHECK_TYPES_2(CONS, ANYTHING, JITTER_ARGF0);
    jitterlisp_object useless __attribute__ ((unused));
    JITTERLISP_SET_CDRB_(useless,
                         JITTER_UNDER_TOP_MAINSTACK(), JITTER_TOP_MAINSTACK());
    /* Leave the two operands on the stack. */
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for !REPLACEMENT-primitive-set-cdrb-special/fR/retR . */

  //fprintf (stderr, "..Executed replacement instruction %s\n", "!REPLACEMENT-primitive-set-cdrb-special/fR/retR");
  //fprintf (stderr, "..Executed instruction %s\n", "!REPLACEMENT-primitive-set-cdrb-special/fR/retR");
//#endif // #if 0
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
#ifdef JITTER_REPLICATE
  {
    /* Advance the instruction pointer, if any, to skip every
       residual but the last; branch back to replicated
       code. */
    const void *_jitter_back_to_replicated_code_pointer =
      JITTER_ARGP1;
    JITTER_SKIP_RESIDUALS_;
    goto * _jitter_back_to_replicated_code_pointer;
  }
#endif // #ifdef JITTER_REPLICATE

    /* Undefine the !REPLACEMENT-primitive-set-cdrb-special/fR/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#ifndef JITTER_REPLICATE
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-primitive-set-cdrb-special/fR/retR, _eREPLACEMENT_mprimitive_mset_mcdrb_mspecial__fR__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#endif // #ifndef JITTER_REPLICATE
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for !REPLACEMENT-primitive-set-cdrb-special/fR/retR, which started with its
       definitions. */
  }
#endif // #if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
/*  End of !REPLACEMENT-primitive-set-cdrb-special/fR/retR , a replacement specialised instruction */

  /* Ordinary specialised instruction !REPLACEMENT-primitive-two-divided/fR/retR (replacement) */
  /* Omit this specialised instruction altogether unless
     replacements are in fact supported in this
     configuration. */
#if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
  JITTER_INSTRUCTION_PROLOG_(!REPLACEMENT-primitive-two-divided/fR/retR, _eREPLACEMENT_mprimitive_mtwo_mdivided__fR__retR, cold)
  { /* This block begins with definitions for !REPLACEMENT-primitive-two-divided/fR/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       327
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         !REPLACEMENT-primitive-two-divided/fR/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "primitive-two-divided"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "!REPLACEMENT-primitive-two-divided/fR/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _eREPLACEMENT_mprimitive_mtwo_mdivided__fR__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST JITTER_BRANCH
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 2

  /* Define argument-access macros for !REPLACEMENT-primitive-two-divided/fR/retR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
    /* The 0th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* When jumping to the non-relocatable part it is important not
   to use a fallback version of JITTER_COMPUTED_GOTO, in order to
   prevent GCC from tail-merging. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
    /* Jump to non-relocatable code. */
    JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);

    /* Here the residual arity is given as zero: it's too late to
       skip residuals, since we've already jumped and this code is
       unreachable.  The instruction pointer, if any, is advanced
       in the non-relocatable code. */
    JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-primitive-two-divided/fR/retR, _eREPLACEMENT_mprimitive_mtwo_mdivided__fR__retR, 0)

    /* Relocated code will jump to this label in non-relocated code. */
  JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
    JITTER_COMMENT_IN_ASM_("!REPLACEMENT-primitive-two-divided/fR/retR non-relocatable code");
#endif // #ifdef JITTER_REPLICATE
#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of !REPLACEMENT-primitive-two-divided/fR/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  no. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
//#if 0
  //fprintf (stderr, "Executing instruction %s..\n", "!REPLACEMENT-primitive-two-divided/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing replacement instruction %s..\n", "!REPLACEMENT-primitive-two-divided/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing non-relocatable instruction %s with JITTER_SPECIALIZED_INSTRUCTION_WORD_NO=%i..\n", "!REPLACEMENT-primitive-two-divided/fR/retR", (int) JITTER_SPECIALIZED_INSTRUCTION_WORD_NO); fflush (stderr);
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#undef JITTER_THIS_IS_A_REPLACEMENT
#define JITTER_THIS_IS_A_REPLACEMENT 1

    /* User code for !REPLACEMENT-primitive-two-divided/fR/retR . */
  {
/* User-specified code, user code block part: beginning. */

    JITTERLISPVM_CHECK_TYPES_1(FIXNUM, JITTER_ARGF0);
    JITTERLISP_2DIVIDED_(JITTER_TOP_MAINSTACK(), JITTER_TOP_MAINSTACK());
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for !REPLACEMENT-primitive-two-divided/fR/retR . */

  //fprintf (stderr, "..Executed replacement instruction %s\n", "!REPLACEMENT-primitive-two-divided/fR/retR");
  //fprintf (stderr, "..Executed instruction %s\n", "!REPLACEMENT-primitive-two-divided/fR/retR");
//#endif // #if 0
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
#ifdef JITTER_REPLICATE
  {
    /* Advance the instruction pointer, if any, to skip every
       residual but the last; branch back to replicated
       code. */
    const void *_jitter_back_to_replicated_code_pointer =
      JITTER_ARGP1;
    JITTER_SKIP_RESIDUALS_;
    goto * _jitter_back_to_replicated_code_pointer;
  }
#endif // #ifdef JITTER_REPLICATE

    /* Undefine the !REPLACEMENT-primitive-two-divided/fR/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#ifndef JITTER_REPLICATE
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-primitive-two-divided/fR/retR, _eREPLACEMENT_mprimitive_mtwo_mdivided__fR__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#endif // #ifndef JITTER_REPLICATE
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for !REPLACEMENT-primitive-two-divided/fR/retR, which started with its
       definitions. */
  }
#endif // #if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
/*  End of !REPLACEMENT-primitive-two-divided/fR/retR , a replacement specialised instruction */

  /* Ordinary specialised instruction !REPLACEMENT-primitive-two-quotient/fR/retR (replacement) */
  /* Omit this specialised instruction altogether unless
     replacements are in fact supported in this
     configuration. */
#if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
  JITTER_INSTRUCTION_PROLOG_(!REPLACEMENT-primitive-two-quotient/fR/retR, _eREPLACEMENT_mprimitive_mtwo_mquotient__fR__retR, cold)
  { /* This block begins with definitions for !REPLACEMENT-primitive-two-quotient/fR/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       328
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         !REPLACEMENT-primitive-two-quotient/fR/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "primitive-two-quotient"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "!REPLACEMENT-primitive-two-quotient/fR/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _eREPLACEMENT_mprimitive_mtwo_mquotient__fR__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST JITTER_BRANCH
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 2

  /* Define argument-access macros for !REPLACEMENT-primitive-two-quotient/fR/retR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
    /* The 0th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* When jumping to the non-relocatable part it is important not
   to use a fallback version of JITTER_COMPUTED_GOTO, in order to
   prevent GCC from tail-merging. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
    /* Jump to non-relocatable code. */
    JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);

    /* Here the residual arity is given as zero: it's too late to
       skip residuals, since we've already jumped and this code is
       unreachable.  The instruction pointer, if any, is advanced
       in the non-relocatable code. */
    JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-primitive-two-quotient/fR/retR, _eREPLACEMENT_mprimitive_mtwo_mquotient__fR__retR, 0)

    /* Relocated code will jump to this label in non-relocated code. */
  JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
    JITTER_COMMENT_IN_ASM_("!REPLACEMENT-primitive-two-quotient/fR/retR non-relocatable code");
#endif // #ifdef JITTER_REPLICATE
#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of !REPLACEMENT-primitive-two-quotient/fR/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  no. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
//#if 0
  //fprintf (stderr, "Executing instruction %s..\n", "!REPLACEMENT-primitive-two-quotient/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing replacement instruction %s..\n", "!REPLACEMENT-primitive-two-quotient/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing non-relocatable instruction %s with JITTER_SPECIALIZED_INSTRUCTION_WORD_NO=%i..\n", "!REPLACEMENT-primitive-two-quotient/fR/retR", (int) JITTER_SPECIALIZED_INSTRUCTION_WORD_NO); fflush (stderr);
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#undef JITTER_THIS_IS_A_REPLACEMENT
#define JITTER_THIS_IS_A_REPLACEMENT 1

    /* User code for !REPLACEMENT-primitive-two-quotient/fR/retR . */
  {
/* User-specified code, user code block part: beginning. */

    JITTERLISPVM_CHECK_TYPES_1(FIXNUM, JITTER_ARGF0);
    JITTERLISP_2QUOTIENT_(JITTER_TOP_MAINSTACK(), JITTER_TOP_MAINSTACK());
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for !REPLACEMENT-primitive-two-quotient/fR/retR . */

  //fprintf (stderr, "..Executed replacement instruction %s\n", "!REPLACEMENT-primitive-two-quotient/fR/retR");
  //fprintf (stderr, "..Executed instruction %s\n", "!REPLACEMENT-primitive-two-quotient/fR/retR");
//#endif // #if 0
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
#ifdef JITTER_REPLICATE
  {
    /* Advance the instruction pointer, if any, to skip every
       residual but the last; branch back to replicated
       code. */
    const void *_jitter_back_to_replicated_code_pointer =
      JITTER_ARGP1;
    JITTER_SKIP_RESIDUALS_;
    goto * _jitter_back_to_replicated_code_pointer;
  }
#endif // #ifdef JITTER_REPLICATE

    /* Undefine the !REPLACEMENT-primitive-two-quotient/fR/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#ifndef JITTER_REPLICATE
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-primitive-two-quotient/fR/retR, _eREPLACEMENT_mprimitive_mtwo_mquotient__fR__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#endif // #ifndef JITTER_REPLICATE
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for !REPLACEMENT-primitive-two-quotient/fR/retR, which started with its
       definitions. */
  }
#endif // #if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
/*  End of !REPLACEMENT-primitive-two-quotient/fR/retR , a replacement specialised instruction */

  /* Ordinary specialised instruction !REPLACEMENT-primitive-two-remainder/fR/retR (replacement) */
  /* Omit this specialised instruction altogether unless
     replacements are in fact supported in this
     configuration. */
#if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
  JITTER_INSTRUCTION_PROLOG_(!REPLACEMENT-primitive-two-remainder/fR/retR, _eREPLACEMENT_mprimitive_mtwo_mremainder__fR__retR, cold)
  { /* This block begins with definitions for !REPLACEMENT-primitive-two-remainder/fR/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       329
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         !REPLACEMENT-primitive-two-remainder/fR/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "primitive-two-remainder"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "!REPLACEMENT-primitive-two-remainder/fR/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _eREPLACEMENT_mprimitive_mtwo_mremainder__fR__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST JITTER_BRANCH
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 2

  /* Define argument-access macros for !REPLACEMENT-primitive-two-remainder/fR/retR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
    /* The 0th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* When jumping to the non-relocatable part it is important not
   to use a fallback version of JITTER_COMPUTED_GOTO, in order to
   prevent GCC from tail-merging. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
    /* Jump to non-relocatable code. */
    JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);

    /* Here the residual arity is given as zero: it's too late to
       skip residuals, since we've already jumped and this code is
       unreachable.  The instruction pointer, if any, is advanced
       in the non-relocatable code. */
    JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-primitive-two-remainder/fR/retR, _eREPLACEMENT_mprimitive_mtwo_mremainder__fR__retR, 0)

    /* Relocated code will jump to this label in non-relocated code. */
  JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
    JITTER_COMMENT_IN_ASM_("!REPLACEMENT-primitive-two-remainder/fR/retR non-relocatable code");
#endif // #ifdef JITTER_REPLICATE
#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of !REPLACEMENT-primitive-two-remainder/fR/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  no. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
//#if 0
  //fprintf (stderr, "Executing instruction %s..\n", "!REPLACEMENT-primitive-two-remainder/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing replacement instruction %s..\n", "!REPLACEMENT-primitive-two-remainder/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing non-relocatable instruction %s with JITTER_SPECIALIZED_INSTRUCTION_WORD_NO=%i..\n", "!REPLACEMENT-primitive-two-remainder/fR/retR", (int) JITTER_SPECIALIZED_INSTRUCTION_WORD_NO); fflush (stderr);
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#undef JITTER_THIS_IS_A_REPLACEMENT
#define JITTER_THIS_IS_A_REPLACEMENT 1

    /* User code for !REPLACEMENT-primitive-two-remainder/fR/retR . */
  {
/* User-specified code, user code block part: beginning. */

    JITTERLISPVM_CHECK_TYPES_1(FIXNUM, JITTER_ARGF0);
    JITTERLISP_2REMAINDER_(JITTER_TOP_MAINSTACK(), JITTER_TOP_MAINSTACK());
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for !REPLACEMENT-primitive-two-remainder/fR/retR . */

  //fprintf (stderr, "..Executed replacement instruction %s\n", "!REPLACEMENT-primitive-two-remainder/fR/retR");
  //fprintf (stderr, "..Executed instruction %s\n", "!REPLACEMENT-primitive-two-remainder/fR/retR");
//#endif // #if 0
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
#ifdef JITTER_REPLICATE
  {
    /* Advance the instruction pointer, if any, to skip every
       residual but the last; branch back to replicated
       code. */
    const void *_jitter_back_to_replicated_code_pointer =
      JITTER_ARGP1;
    JITTER_SKIP_RESIDUALS_;
    goto * _jitter_back_to_replicated_code_pointer;
  }
#endif // #ifdef JITTER_REPLICATE

    /* Undefine the !REPLACEMENT-primitive-two-remainder/fR/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#ifndef JITTER_REPLICATE
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-primitive-two-remainder/fR/retR, _eREPLACEMENT_mprimitive_mtwo_mremainder__fR__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#endif // #ifndef JITTER_REPLICATE
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for !REPLACEMENT-primitive-two-remainder/fR/retR, which started with its
       definitions. */
  }
#endif // #if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
/*  End of !REPLACEMENT-primitive-two-remainder/fR/retR , a replacement specialised instruction */

  /* Ordinary specialised instruction !REPLACEMENT-primitive-two-times/fR/retR (replacement) */
  /* Omit this specialised instruction altogether unless
     replacements are in fact supported in this
     configuration. */
#if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
  JITTER_INSTRUCTION_PROLOG_(!REPLACEMENT-primitive-two-times/fR/retR, _eREPLACEMENT_mprimitive_mtwo_mtimes__fR__retR, cold)
  { /* This block begins with definitions for !REPLACEMENT-primitive-two-times/fR/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       330
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         !REPLACEMENT-primitive-two-times/fR/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "primitive-two-times"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "!REPLACEMENT-primitive-two-times/fR/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _eREPLACEMENT_mprimitive_mtwo_mtimes__fR__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST JITTER_BRANCH
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 2

  /* Define argument-access macros for !REPLACEMENT-primitive-two-times/fR/retR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
    /* The 0th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* When jumping to the non-relocatable part it is important not
   to use a fallback version of JITTER_COMPUTED_GOTO, in order to
   prevent GCC from tail-merging. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
    /* Jump to non-relocatable code. */
    JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);

    /* Here the residual arity is given as zero: it's too late to
       skip residuals, since we've already jumped and this code is
       unreachable.  The instruction pointer, if any, is advanced
       in the non-relocatable code. */
    JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-primitive-two-times/fR/retR, _eREPLACEMENT_mprimitive_mtwo_mtimes__fR__retR, 0)

    /* Relocated code will jump to this label in non-relocated code. */
  JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
    JITTER_COMMENT_IN_ASM_("!REPLACEMENT-primitive-two-times/fR/retR non-relocatable code");
#endif // #ifdef JITTER_REPLICATE
#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of !REPLACEMENT-primitive-two-times/fR/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  no. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
//#if 0
  //fprintf (stderr, "Executing instruction %s..\n", "!REPLACEMENT-primitive-two-times/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing replacement instruction %s..\n", "!REPLACEMENT-primitive-two-times/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing non-relocatable instruction %s with JITTER_SPECIALIZED_INSTRUCTION_WORD_NO=%i..\n", "!REPLACEMENT-primitive-two-times/fR/retR", (int) JITTER_SPECIALIZED_INSTRUCTION_WORD_NO); fflush (stderr);
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#undef JITTER_THIS_IS_A_REPLACEMENT
#define JITTER_THIS_IS_A_REPLACEMENT 1

    /* User code for !REPLACEMENT-primitive-two-times/fR/retR . */
  {
/* User-specified code, user code block part: beginning. */

    JITTERLISPVM_CHECK_TYPES_1(FIXNUM, JITTER_ARGF0);
    JITTERLISP_2TIMES_OR_OVERFLOW_(JITTER_TOP_MAINSTACK(),
                                   JITTER_TOP_MAINSTACK(),
                                   JITTER_ARGF0);
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for !REPLACEMENT-primitive-two-times/fR/retR . */

  //fprintf (stderr, "..Executed replacement instruction %s\n", "!REPLACEMENT-primitive-two-times/fR/retR");
  //fprintf (stderr, "..Executed instruction %s\n", "!REPLACEMENT-primitive-two-times/fR/retR");
//#endif // #if 0
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
#ifdef JITTER_REPLICATE
  {
    /* Advance the instruction pointer, if any, to skip every
       residual but the last; branch back to replicated
       code. */
    const void *_jitter_back_to_replicated_code_pointer =
      JITTER_ARGP1;
    JITTER_SKIP_RESIDUALS_;
    goto * _jitter_back_to_replicated_code_pointer;
  }
#endif // #ifdef JITTER_REPLICATE

    /* Undefine the !REPLACEMENT-primitive-two-times/fR/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#ifndef JITTER_REPLICATE
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-primitive-two-times/fR/retR, _eREPLACEMENT_mprimitive_mtwo_mtimes__fR__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#endif // #ifndef JITTER_REPLICATE
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for !REPLACEMENT-primitive-two-times/fR/retR, which started with its
       definitions. */
  }
#endif // #if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
/*  End of !REPLACEMENT-primitive-two-times/fR/retR , a replacement specialised instruction */

  /* Ordinary specialised instruction !REPLACEMENT-primitive-zerop/fR/retR (replacement) */
  /* Omit this specialised instruction altogether unless
     replacements are in fact supported in this
     configuration. */
#if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
  JITTER_INSTRUCTION_PROLOG_(!REPLACEMENT-primitive-zerop/fR/retR, _eREPLACEMENT_mprimitive_mzerop__fR__retR, cold)
  { /* This block begins with definitions for !REPLACEMENT-primitive-zerop/fR/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       331
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         !REPLACEMENT-primitive-zerop/fR/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "primitive-zerop"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "!REPLACEMENT-primitive-zerop/fR/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _eREPLACEMENT_mprimitive_mzerop__fR__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST JITTER_BRANCH
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 2

  /* Define argument-access macros for !REPLACEMENT-primitive-zerop/fR/retR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
    /* The 0th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* When jumping to the non-relocatable part it is important not
   to use a fallback version of JITTER_COMPUTED_GOTO, in order to
   prevent GCC from tail-merging. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
    /* Jump to non-relocatable code. */
    JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);

    /* Here the residual arity is given as zero: it's too late to
       skip residuals, since we've already jumped and this code is
       unreachable.  The instruction pointer, if any, is advanced
       in the non-relocatable code. */
    JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-primitive-zerop/fR/retR, _eREPLACEMENT_mprimitive_mzerop__fR__retR, 0)

    /* Relocated code will jump to this label in non-relocated code. */
  JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
    JITTER_COMMENT_IN_ASM_("!REPLACEMENT-primitive-zerop/fR/retR non-relocatable code");
#endif // #ifdef JITTER_REPLICATE
#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of !REPLACEMENT-primitive-zerop/fR/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  no. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
//#if 0
  //fprintf (stderr, "Executing instruction %s..\n", "!REPLACEMENT-primitive-zerop/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing replacement instruction %s..\n", "!REPLACEMENT-primitive-zerop/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing non-relocatable instruction %s with JITTER_SPECIALIZED_INSTRUCTION_WORD_NO=%i..\n", "!REPLACEMENT-primitive-zerop/fR/retR", (int) JITTER_SPECIALIZED_INSTRUCTION_WORD_NO); fflush (stderr);
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#undef JITTER_THIS_IS_A_REPLACEMENT
#define JITTER_THIS_IS_A_REPLACEMENT 1

    /* User code for !REPLACEMENT-primitive-zerop/fR/retR . */
  {
/* User-specified code, user code block part: beginning. */

    JITTERLISPVM_CHECK_TYPES_1(FIXNUM, JITTER_ARGF0);
    JITTERLISP_ZEROP_(JITTER_TOP_MAINSTACK(), JITTER_TOP_MAINSTACK());
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for !REPLACEMENT-primitive-zerop/fR/retR . */

  //fprintf (stderr, "..Executed replacement instruction %s\n", "!REPLACEMENT-primitive-zerop/fR/retR");
  //fprintf (stderr, "..Executed instruction %s\n", "!REPLACEMENT-primitive-zerop/fR/retR");
//#endif // #if 0
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
#ifdef JITTER_REPLICATE
  {
    /* Advance the instruction pointer, if any, to skip every
       residual but the last; branch back to replicated
       code. */
    const void *_jitter_back_to_replicated_code_pointer =
      JITTER_ARGP1;
    JITTER_SKIP_RESIDUALS_;
    goto * _jitter_back_to_replicated_code_pointer;
  }
#endif // #ifdef JITTER_REPLICATE

    /* Undefine the !REPLACEMENT-primitive-zerop/fR/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#ifndef JITTER_REPLICATE
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-primitive-zerop/fR/retR, _eREPLACEMENT_mprimitive_mzerop__fR__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#endif // #ifndef JITTER_REPLICATE
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for !REPLACEMENT-primitive-zerop/fR/retR, which started with its
       definitions. */
  }
#endif // #if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
/*  End of !REPLACEMENT-primitive-zerop/fR/retR , a replacement specialised instruction */

  /* Ordinary specialised instruction !REPLACEMENT-procedure-prolog/retR (replacement) */
  /* Omit this specialised instruction altogether unless
     replacements are in fact supported in this
     configuration. */
#if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
  JITTER_INSTRUCTION_PROLOG_(!REPLACEMENT-procedure-prolog/retR, _eREPLACEMENT_mprocedure_mprolog__retR, cold)
  { /* This block begins with definitions for !REPLACEMENT-procedure-prolog/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       332
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         !REPLACEMENT-procedure-prolog/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "procedure-prolog"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "!REPLACEMENT-procedure-prolog/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _eREPLACEMENT_mprocedure_mprolog__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is non-relocatable.
       Its 0-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is non-relocatable.
       Its 0-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1

    /* The 0th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0


  /* This specialized instruction is a replacement callee. */
# undef JITTER_LINK
# define JITTER_LINK ((const void *) (jitter_state_runtime._jitter_link.label))

#ifdef JITTER_REPLICATE
/* When jumping to the non-relocatable part it is important not
   to use a fallback version of JITTER_COMPUTED_GOTO, in order to
   prevent GCC from tail-merging. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
    /* Jump to non-relocatable code. */
    JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);

    /* Here the residual arity is given as zero: it's too late to
       skip residuals, since we've already jumped and this code is
       unreachable.  The instruction pointer, if any, is advanced
       in the non-relocatable code. */
    JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-procedure-prolog/retR, _eREPLACEMENT_mprocedure_mprolog__retR, 0)

    /* Relocated code will jump to this label in non-relocated code. */
  JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
    JITTER_COMMENT_IN_ASM_("!REPLACEMENT-procedure-prolog/retR non-relocatable code");
#endif // #ifdef JITTER_REPLICATE
#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of !REPLACEMENT-procedure-prolog/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  no. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
//#if 0
  //fprintf (stderr, "Executing instruction %s..\n", "!REPLACEMENT-procedure-prolog/retR"); fflush (stderr);
  //fprintf (stderr, "Executing replacement instruction %s..\n", "!REPLACEMENT-procedure-prolog/retR"); fflush (stderr);
  //fprintf (stderr, "Executing non-relocatable instruction %s with JITTER_SPECIALIZED_INSTRUCTION_WORD_NO=%i..\n", "!REPLACEMENT-procedure-prolog/retR", (int) JITTER_SPECIALIZED_INSTRUCTION_WORD_NO); fflush (stderr);
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#undef JITTER_THIS_IS_A_REPLACEMENT
#define JITTER_THIS_IS_A_REPLACEMENT 1

    /* User code for !REPLACEMENT-procedure-prolog/retR . */
  {
/* User-specified code, user code block part: beginning. */

    /* Fill the return stack slot with the return address.  The return
       stack has already been pushed (with an unspecified value on the
       top) by the caller. */
    JITTER_TOP_RETURNSTACK() = (jitterlisp_object) JITTER_LINK;
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for !REPLACEMENT-procedure-prolog/retR . */

  //fprintf (stderr, "..Executed replacement instruction %s\n", "!REPLACEMENT-procedure-prolog/retR");
  //fprintf (stderr, "..Executed instruction %s\n", "!REPLACEMENT-procedure-prolog/retR");
//#endif // #if 0
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
#ifdef JITTER_REPLICATE
  {
    /* Advance the instruction pointer, if any, to skip every
       residual but the last; branch back to replicated
       code. */
    const void *_jitter_back_to_replicated_code_pointer =
      JITTER_ARGP0;
    JITTER_SKIP_RESIDUALS_;
    goto * _jitter_back_to_replicated_code_pointer;
  }
#endif // #ifdef JITTER_REPLICATE

    /* Undefine the !REPLACEMENT-procedure-prolog/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

  /* Undefine the link macro. */
#   undef JITTER_LINK

#ifndef JITTER_REPLICATE
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-procedure-prolog/retR, _eREPLACEMENT_mprocedure_mprolog__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#endif // #ifndef JITTER_REPLICATE
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for !REPLACEMENT-procedure-prolog/retR, which started with its
       definitions. */
  }
#endif // #if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
/*  End of !REPLACEMENT-procedure-prolog/retR , a replacement specialised instruction */

  /* Ordinary specialised instruction !REPLACEMENT-push-global/nR/fR/retR (replacement) */
  /* Omit this specialised instruction altogether unless
     replacements are in fact supported in this
     configuration. */
#if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
  JITTER_INSTRUCTION_PROLOG_(!REPLACEMENT-push-global/nR/fR/retR, _eREPLACEMENT_mpush_mglobal__nR__fR__retR, cold)
  { /* This block begins with definitions for !REPLACEMENT-push-global/nR/fR/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       333
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         !REPLACEMENT-push-global/nR/fR/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "push-global"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "!REPLACEMENT-push-global/nR/fR/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _eREPLACEMENT_mpush_mglobal__nR__fR__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is non-relocatable.
       Its 2-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   define JITTER_BRANCH_FAST JITTER_BRANCH
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
#   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
    /* This specialized instruction is non-relocatable.
       Its 2-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 3

  /* Define argument-access macros for !REPLACEMENT-push-global/nR/fR/retR . */
#ifdef JITTER_HAVE_PATCH_IN
  /* Define argument-access macros assuming that fast branches are enabled. */
    /* The 0th argument is a residual literal. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

    /* The 2th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG2  JITTER_RESIDUAL_ARGUMENT_2
    JITTER_MARK_RESIDUAL_2_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[2])
#else
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[3])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN2 (JITTER_ARG2.fixnum)
#   define JITTER_ARGU2 (JITTER_ARG2.ufixnum)
#   define JITTER_ARGP2 (JITTER_ARG2.pointer)

#else
  /* Define argument-access macros assuming that fast branches are disabled. */
    /* The 0th argument is a residual literal. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1

    /* The 2th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG2  JITTER_RESIDUAL_ARGUMENT_2
    JITTER_MARK_RESIDUAL_2_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[2])
#else
#   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[3])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN2 (JITTER_ARG2.fixnum)
#   define JITTER_ARGU2 (JITTER_ARG2.ufixnum)
#   define JITTER_ARGP2 (JITTER_ARG2.pointer)
#   define JITTER_ARGF2 JITTER_ARGP2

# endif // #ifdef JITTER_HAVE_PATCH_IN

#ifdef JITTER_REPLICATE
/* When jumping to the non-relocatable part it is important not
   to use a fallback version of JITTER_COMPUTED_GOTO, in order to
   prevent GCC from tail-merging. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
    /* Jump to non-relocatable code. */
    JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);

    /* Here the residual arity is given as zero: it's too late to
       skip residuals, since we've already jumped and this code is
       unreachable.  The instruction pointer, if any, is advanced
       in the non-relocatable code. */
    JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-push-global/nR/fR/retR, _eREPLACEMENT_mpush_mglobal__nR__fR__retR, 0)

    /* Relocated code will jump to this label in non-relocated code. */
  JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
    JITTER_COMMENT_IN_ASM_("!REPLACEMENT-push-global/nR/fR/retR non-relocatable code");
#endif // #ifdef JITTER_REPLICATE
#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of !REPLACEMENT-push-global/nR/fR/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  no. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
//#if 0
  //fprintf (stderr, "Executing instruction %s..\n", "!REPLACEMENT-push-global/nR/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing replacement instruction %s..\n", "!REPLACEMENT-push-global/nR/fR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing non-relocatable instruction %s with JITTER_SPECIALIZED_INSTRUCTION_WORD_NO=%i..\n", "!REPLACEMENT-push-global/nR/fR/retR", (int) JITTER_SPECIALIZED_INSTRUCTION_WORD_NO); fflush (stderr);
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#undef JITTER_THIS_IS_A_REPLACEMENT
#define JITTER_THIS_IS_A_REPLACEMENT 1

    /* User code for !REPLACEMENT-push-global/nR/fR/retR . */
  {
/* User-specified code, user code block part: beginning. */

    jitterlisp_object tagged_symbol = JITTER_ARGN0;
    struct jitterlisp_symbol * symbol = JITTERLISP_SYMBOL_DECODE(tagged_symbol);

#ifndef JITTERLISP_UNSAFE
    JITTER_BRANCH_FAST_IF_EQUAL (symbol->global_value, JITTERLISP_UNDEFINED,
                                 JITTER_ARGF1);
#endif // #ifndef JITTERLISP_UNSAFE

//    JITTER_PUSH_MAINSTACK(symbol->global_value);
    JITTER_PUSH_UNSPECIFIED_MAINSTACK();
    JITTER_TOP_MAINSTACK() = symbol->global_value;
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for !REPLACEMENT-push-global/nR/fR/retR . */

  //fprintf (stderr, "..Executed replacement instruction %s\n", "!REPLACEMENT-push-global/nR/fR/retR");
  //fprintf (stderr, "..Executed instruction %s\n", "!REPLACEMENT-push-global/nR/fR/retR");
//#endif // #if 0
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
#ifdef JITTER_REPLICATE
  {
    /* Advance the instruction pointer, if any, to skip every
       residual but the last; branch back to replicated
       code. */
    const void *_jitter_back_to_replicated_code_pointer =
      JITTER_ARGP2;
    JITTER_SKIP_RESIDUALS_;
    goto * _jitter_back_to_replicated_code_pointer;
  }
#endif // #ifdef JITTER_REPLICATE

    /* Undefine the !REPLACEMENT-push-global/nR/fR/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1
#   undef JITTER_SLOW_REGISTER_OFFSET2
#   undef JITTER_ARG2
#   undef JITTER_ARGN2
#   undef JITTER_ARGU2
#   undef JITTER_ARGP2
#   undef JITTER_ARGF2

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#ifndef JITTER_REPLICATE
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-push-global/nR/fR/retR, _eREPLACEMENT_mpush_mglobal__nR__fR__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#endif // #ifndef JITTER_REPLICATE
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for !REPLACEMENT-push-global/nR/fR/retR, which started with its
       definitions. */
  }
#endif // #if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
/*  End of !REPLACEMENT-push-global/nR/fR/retR , a replacement specialised instruction */

  /* Ordinary specialised instruction !REPLACEMENT-return/retR (replacement) */
  /* Omit this specialised instruction altogether unless
     replacements are in fact supported in this
     configuration. */
#if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
  JITTER_INSTRUCTION_PROLOG_(!REPLACEMENT-return/retR, _eREPLACEMENT_mreturn__retR, cold)
  { /* This block begins with definitions for !REPLACEMENT-return/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       334
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         !REPLACEMENT-return/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "return"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "!REPLACEMENT-return/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _eREPLACEMENT_mreturn__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is non-relocatable.
       Its 0-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is non-relocatable.
       Its 0-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is returning, and non-relocatable. */
#   define JITTER_RETURN  _JITTER_RETURN_FALLBACK

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1

    /* The 0th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0


#ifdef JITTER_REPLICATE
/* When jumping to the non-relocatable part it is important not
   to use a fallback version of JITTER_COMPUTED_GOTO, in order to
   prevent GCC from tail-merging. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
    /* Jump to non-relocatable code. */
    JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);

    /* Here the residual arity is given as zero: it's too late to
       skip residuals, since we've already jumped and this code is
       unreachable.  The instruction pointer, if any, is advanced
       in the non-relocatable code. */
    JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-return/retR, _eREPLACEMENT_mreturn__retR, 0)

    /* Relocated code will jump to this label in non-relocated code. */
  JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
    JITTER_COMMENT_IN_ASM_("!REPLACEMENT-return/retR non-relocatable code");
#endif // #ifdef JITTER_REPLICATE
#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of !REPLACEMENT-return/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  no. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
//#if 0
  //fprintf (stderr, "Executing instruction %s..\n", "!REPLACEMENT-return/retR"); fflush (stderr);
  //fprintf (stderr, "Executing replacement instruction %s..\n", "!REPLACEMENT-return/retR"); fflush (stderr);
  //fprintf (stderr, "Executing non-relocatable instruction %s with JITTER_SPECIALIZED_INSTRUCTION_WORD_NO=%i..\n", "!REPLACEMENT-return/retR", (int) JITTER_SPECIALIZED_INSTRUCTION_WORD_NO); fflush (stderr);
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#undef JITTER_THIS_IS_A_REPLACEMENT
#define JITTER_THIS_IS_A_REPLACEMENT 1

    /* User code for !REPLACEMENT-return/retR . */
  {
/* User-specified code, user code block part: beginning. */

    jitter_uint return_address = JITTER_TOP_RETURNSTACK();
    JITTER_DROP_RETURNSTACK();
    JITTER_RETURN(return_address);
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for !REPLACEMENT-return/retR . */

  //fprintf (stderr, "..Executed replacement instruction %s\n", "!REPLACEMENT-return/retR");
  //fprintf (stderr, "..Executed instruction %s\n", "!REPLACEMENT-return/retR");
//#endif // #if 0
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
#ifdef JITTER_REPLICATE
  {
    /* Advance the instruction pointer, if any, to skip every
       residual but the last; branch back to replicated
       code. */
    const void *_jitter_back_to_replicated_code_pointer =
      JITTER_ARGP0;
    JITTER_SKIP_RESIDUALS_;
    goto * _jitter_back_to_replicated_code_pointer;
  }
#endif // #ifdef JITTER_REPLICATE

    /* Undefine the !REPLACEMENT-return/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#ifndef JITTER_REPLICATE
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-return/retR, _eREPLACEMENT_mreturn__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#endif // #ifndef JITTER_REPLICATE
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for !REPLACEMENT-return/retR, which started with its
       definitions. */
  }
#endif // #if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
/*  End of !REPLACEMENT-return/retR , a replacement specialised instruction */

  /* Ordinary specialised instruction !REPLACEMENT-tail-call/n0/retR (replacement) */
  /* Omit this specialised instruction altogether unless
     replacements are in fact supported in this
     configuration. */
#if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
  JITTER_INSTRUCTION_PROLOG_(!REPLACEMENT-tail-call/n0/retR, _eREPLACEMENT_mtail_mcall__n0__retR, cold)
  { /* This block begins with definitions for !REPLACEMENT-tail-call/n0/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       335
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         !REPLACEMENT-tail-call/n0/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "tail-call"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "!REPLACEMENT-tail-call/n0/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _eREPLACEMENT_mtail_mcall__n0__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement and a caller.
       Its 1-th argument, a literal, is the return address where to jump
       back after the procedure returns.  Branch-and-link
       functionality is enabled for this instruction. */
/* This instruction is non-relocatable: use branches which
   cannot ever generate defects. */
#   undef JITTER_BRANCH_AND_LINK
#   define JITTER_BRANCH_AND_LINK      _JITTER_BRANCH_AND_LINK_FALLBACK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   define JITTER_BRANCH_AND_LINK_WITH _JITTER_BRANCH_AND_LINK_WITH_FALLBACK
#   undef JITTER_BRANCH_FAST_AND_LINK
#   define JITTER_BRANCH_FAST_AND_LINK _JITTER_BRANCH_AND_LINK_FALLBACK

    /* This specialized instruction is returning, and non-relocatable. */
#   define JITTER_RETURN  _JITTER_RETURN_FALLBACK

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1

    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 0L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1


#ifdef JITTER_REPLICATE
/* When jumping to the non-relocatable part it is important not
   to use a fallback version of JITTER_COMPUTED_GOTO, in order to
   prevent GCC from tail-merging. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
    /* Jump to non-relocatable code. */
    JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);

    /* Here the residual arity is given as zero: it's too late to
       skip residuals, since we've already jumped and this code is
       unreachable.  The instruction pointer, if any, is advanced
       in the non-relocatable code. */
    JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-tail-call/n0/retR, _eREPLACEMENT_mtail_mcall__n0__retR, 0)

    /* Relocated code will jump to this label in non-relocated code. */
  JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
    JITTER_COMMENT_IN_ASM_("!REPLACEMENT-tail-call/n0/retR non-relocatable code");
#endif // #ifdef JITTER_REPLICATE
#if defined(JITTER_DISPATCH_NO_THREADING)             \
    && (! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)  \
        || /* is this a replacement? */ 1)
  /* We use the implicit argument at the end of the calling.
     instruction to discover the procedure return address. */
  const void * const _jitter_return_pointer
    __attribute__ ((unused)) = JITTER_ARGP1;
  /* And make it accessible to the user (who will usually call 
     JITTER_BRANCH_AND_LINK) thru a nice macro. */
# define _JITTER_RETURN_ADDRESS _jitter_return_pointer
#endif

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of !REPLACEMENT-tail-call/n0/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  no. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
//#if 0
  //fprintf (stderr, "Executing instruction %s..\n", "!REPLACEMENT-tail-call/n0/retR"); fflush (stderr);
  //fprintf (stderr, "Executing replacement instruction %s..\n", "!REPLACEMENT-tail-call/n0/retR"); fflush (stderr);
  //fprintf (stderr, "Executing non-relocatable instruction %s with JITTER_SPECIALIZED_INSTRUCTION_WORD_NO=%i..\n", "!REPLACEMENT-tail-call/n0/retR", (int) JITTER_SPECIALIZED_INSTRUCTION_WORD_NO); fflush (stderr);
  //fprintf (stderr, "Executing caller replcament: _JITTER_RETURN_ADDRESS is %p..\n", _JITTER_RETURN_ADDRESS); fflush (stderr);
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#undef JITTER_THIS_IS_A_REPLACEMENT
#define JITTER_THIS_IS_A_REPLACEMENT 1

    /* User code for !REPLACEMENT-tail-call/n0/retR . */
  {
/* User-specified code, user code block part: beginning. */

    const jitter_uint in_arity = JITTER_ARGN0;
    jitterlisp_object callee = JITTER_AT_DEPTH_MAINSTACK(in_arity);
    struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(callee);

    if (c->kind == jitterlisp_closure_type_compiled)
      {
        /* Extract the current return address from the return stack, to be
           reused.  Differently from non-tail calls, don't push anything on
           the return stack: the callee will overwrite the top with its
           current value, which is what we want. */
        jitterlispvm_program_point current_link
          = (jitterlispvm_program_point) JITTER_TOP_RETURNSTACK();

        /* Branch-and-relink to the native code, whose first instruction
           will be a prolog. */
        struct jitterlisp_compiled_closure *cc = & c->compiled;
        JITTER_BRANCH_AND_LINK_WITH(cc->first_program_point, current_link);
      }
    else
      {
        /* Unfortunately I cannot really tail-call from compiled code to
           interpreted code.  Instead I will call the interpreter as a C
           function and then return. */
        const struct jitterlisp_interpreted_closure *ic = & c->interpreted;

        /* Push an element on the main stack.  This way we can ensure that
           every actual is accessible thru memory in a contiguous array,
           even if the main stack is TOS-optimized.  Compute the address
           (on the main stack backing) where the actuals begin.

           Notice that the interpreted function we are calling is allowed
           to call into compiled code in its turn.  This is not a problem,
           as we are not moving stack pointers down until the call ends:
           the unused part of the main and return stacks is available to
           the callee. */
        JITTER_PUSH_UNSPECIFIED_MAINSTACK();
        jitterlisp_object *actuals
          // FIXME: add a stack operator to compute this address.
          = (& JITTER_UNDER_TOP_MAINSTACK()) - in_arity + 1;

        /* Call the interpreter. */
        jitterlisp_object interpretation_result
          = jitterlisp_call_interpreted (ic, actuals, in_arity);

        /* Remove as many elements as the in-arity plus one (the callee) from
           the stack, without affecting the top.  Unless JITTER_ARGN0 is
           residual this whole loops compiles to one instruction when the main
           stack is TOS-optimized, and doesn't touch memory. */
        int i;
        for (i = 0; i < in_arity + 1; i ++)
          JITTER_NIP_MAINSTACK();

        /* Now the stack is one element higher than it was before the call,
           containing the unspecified element at the top.  Replace it with
           the result.  Again this doesn't touch memory. */
        JITTER_TOP_MAINSTACK() = interpretation_result;

        /* Return to our original caller. */
        jitter_uint return_address = JITTER_TOP_RETURNSTACK();
        JITTER_DROP_RETURNSTACK();
        JITTER_RETURN(return_address);
      }
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for !REPLACEMENT-tail-call/n0/retR . */

  //fprintf (stderr, "..Executed replacement instruction %s\n", "!REPLACEMENT-tail-call/n0/retR");
  //fprintf (stderr, "..Executed instruction %s\n", "!REPLACEMENT-tail-call/n0/retR");
//#endif // #if 0
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
#ifdef JITTER_REPLICATE
  {
    /* Advance the instruction pointer, if any, to skip every
       residual but the last; branch back to replicated
       code. */
    const void *_jitter_back_to_replicated_code_pointer =
      JITTER_ARGP1;
    JITTER_SKIP_RESIDUALS_;
    goto * _jitter_back_to_replicated_code_pointer;
  }
#endif // #ifdef JITTER_REPLICATE

    /* Undefine the !REPLACEMENT-tail-call/n0/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#if    defined(JITTER_DISPATCH_NO_THREADING)         \
    && ! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)
# undef _JITTER_RETURN_ADDRESS
#endif

#ifndef JITTER_REPLICATE
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-tail-call/n0/retR, _eREPLACEMENT_mtail_mcall__n0__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#endif // #ifndef JITTER_REPLICATE
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for !REPLACEMENT-tail-call/n0/retR, which started with its
       definitions. */
  }
#endif // #if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
/*  End of !REPLACEMENT-tail-call/n0/retR , a replacement specialised instruction */

  /* Ordinary specialised instruction !REPLACEMENT-tail-call/n1/retR (replacement) */
  /* Omit this specialised instruction altogether unless
     replacements are in fact supported in this
     configuration. */
#if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
  JITTER_INSTRUCTION_PROLOG_(!REPLACEMENT-tail-call/n1/retR, _eREPLACEMENT_mtail_mcall__n1__retR, cold)
  { /* This block begins with definitions for !REPLACEMENT-tail-call/n1/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       336
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         !REPLACEMENT-tail-call/n1/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "tail-call"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "!REPLACEMENT-tail-call/n1/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _eREPLACEMENT_mtail_mcall__n1__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement and a caller.
       Its 1-th argument, a literal, is the return address where to jump
       back after the procedure returns.  Branch-and-link
       functionality is enabled for this instruction. */
/* This instruction is non-relocatable: use branches which
   cannot ever generate defects. */
#   undef JITTER_BRANCH_AND_LINK
#   define JITTER_BRANCH_AND_LINK      _JITTER_BRANCH_AND_LINK_FALLBACK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   define JITTER_BRANCH_AND_LINK_WITH _JITTER_BRANCH_AND_LINK_WITH_FALLBACK
#   undef JITTER_BRANCH_FAST_AND_LINK
#   define JITTER_BRANCH_FAST_AND_LINK _JITTER_BRANCH_AND_LINK_FALLBACK

    /* This specialized instruction is returning, and non-relocatable. */
#   define JITTER_RETURN  _JITTER_RETURN_FALLBACK

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1

    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 1L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1


#ifdef JITTER_REPLICATE
/* When jumping to the non-relocatable part it is important not
   to use a fallback version of JITTER_COMPUTED_GOTO, in order to
   prevent GCC from tail-merging. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
    /* Jump to non-relocatable code. */
    JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);

    /* Here the residual arity is given as zero: it's too late to
       skip residuals, since we've already jumped and this code is
       unreachable.  The instruction pointer, if any, is advanced
       in the non-relocatable code. */
    JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-tail-call/n1/retR, _eREPLACEMENT_mtail_mcall__n1__retR, 0)

    /* Relocated code will jump to this label in non-relocated code. */
  JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
    JITTER_COMMENT_IN_ASM_("!REPLACEMENT-tail-call/n1/retR non-relocatable code");
#endif // #ifdef JITTER_REPLICATE
#if defined(JITTER_DISPATCH_NO_THREADING)             \
    && (! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)  \
        || /* is this a replacement? */ 1)
  /* We use the implicit argument at the end of the calling.
     instruction to discover the procedure return address. */
  const void * const _jitter_return_pointer
    __attribute__ ((unused)) = JITTER_ARGP1;
  /* And make it accessible to the user (who will usually call 
     JITTER_BRANCH_AND_LINK) thru a nice macro. */
# define _JITTER_RETURN_ADDRESS _jitter_return_pointer
#endif

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of !REPLACEMENT-tail-call/n1/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  no. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
//#if 0
  //fprintf (stderr, "Executing instruction %s..\n", "!REPLACEMENT-tail-call/n1/retR"); fflush (stderr);
  //fprintf (stderr, "Executing replacement instruction %s..\n", "!REPLACEMENT-tail-call/n1/retR"); fflush (stderr);
  //fprintf (stderr, "Executing non-relocatable instruction %s with JITTER_SPECIALIZED_INSTRUCTION_WORD_NO=%i..\n", "!REPLACEMENT-tail-call/n1/retR", (int) JITTER_SPECIALIZED_INSTRUCTION_WORD_NO); fflush (stderr);
  //fprintf (stderr, "Executing caller replcament: _JITTER_RETURN_ADDRESS is %p..\n", _JITTER_RETURN_ADDRESS); fflush (stderr);
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#undef JITTER_THIS_IS_A_REPLACEMENT
#define JITTER_THIS_IS_A_REPLACEMENT 1

    /* User code for !REPLACEMENT-tail-call/n1/retR . */
  {
/* User-specified code, user code block part: beginning. */

    const jitter_uint in_arity = JITTER_ARGN0;
    jitterlisp_object callee = JITTER_AT_DEPTH_MAINSTACK(in_arity);
    struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(callee);

    if (c->kind == jitterlisp_closure_type_compiled)
      {
        /* Extract the current return address from the return stack, to be
           reused.  Differently from non-tail calls, don't push anything on
           the return stack: the callee will overwrite the top with its
           current value, which is what we want. */
        jitterlispvm_program_point current_link
          = (jitterlispvm_program_point) JITTER_TOP_RETURNSTACK();

        /* Branch-and-relink to the native code, whose first instruction
           will be a prolog. */
        struct jitterlisp_compiled_closure *cc = & c->compiled;
        JITTER_BRANCH_AND_LINK_WITH(cc->first_program_point, current_link);
      }
    else
      {
        /* Unfortunately I cannot really tail-call from compiled code to
           interpreted code.  Instead I will call the interpreter as a C
           function and then return. */
        const struct jitterlisp_interpreted_closure *ic = & c->interpreted;

        /* Push an element on the main stack.  This way we can ensure that
           every actual is accessible thru memory in a contiguous array,
           even if the main stack is TOS-optimized.  Compute the address
           (on the main stack backing) where the actuals begin.

           Notice that the interpreted function we are calling is allowed
           to call into compiled code in its turn.  This is not a problem,
           as we are not moving stack pointers down until the call ends:
           the unused part of the main and return stacks is available to
           the callee. */
        JITTER_PUSH_UNSPECIFIED_MAINSTACK();
        jitterlisp_object *actuals
          // FIXME: add a stack operator to compute this address.
          = (& JITTER_UNDER_TOP_MAINSTACK()) - in_arity + 1;

        /* Call the interpreter. */
        jitterlisp_object interpretation_result
          = jitterlisp_call_interpreted (ic, actuals, in_arity);

        /* Remove as many elements as the in-arity plus one (the callee) from
           the stack, without affecting the top.  Unless JITTER_ARGN0 is
           residual this whole loops compiles to one instruction when the main
           stack is TOS-optimized, and doesn't touch memory. */
        int i;
        for (i = 0; i < in_arity + 1; i ++)
          JITTER_NIP_MAINSTACK();

        /* Now the stack is one element higher than it was before the call,
           containing the unspecified element at the top.  Replace it with
           the result.  Again this doesn't touch memory. */
        JITTER_TOP_MAINSTACK() = interpretation_result;

        /* Return to our original caller. */
        jitter_uint return_address = JITTER_TOP_RETURNSTACK();
        JITTER_DROP_RETURNSTACK();
        JITTER_RETURN(return_address);
      }
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for !REPLACEMENT-tail-call/n1/retR . */

  //fprintf (stderr, "..Executed replacement instruction %s\n", "!REPLACEMENT-tail-call/n1/retR");
  //fprintf (stderr, "..Executed instruction %s\n", "!REPLACEMENT-tail-call/n1/retR");
//#endif // #if 0
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
#ifdef JITTER_REPLICATE
  {
    /* Advance the instruction pointer, if any, to skip every
       residual but the last; branch back to replicated
       code. */
    const void *_jitter_back_to_replicated_code_pointer =
      JITTER_ARGP1;
    JITTER_SKIP_RESIDUALS_;
    goto * _jitter_back_to_replicated_code_pointer;
  }
#endif // #ifdef JITTER_REPLICATE

    /* Undefine the !REPLACEMENT-tail-call/n1/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#if    defined(JITTER_DISPATCH_NO_THREADING)         \
    && ! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)
# undef _JITTER_RETURN_ADDRESS
#endif

#ifndef JITTER_REPLICATE
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-tail-call/n1/retR, _eREPLACEMENT_mtail_mcall__n1__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#endif // #ifndef JITTER_REPLICATE
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for !REPLACEMENT-tail-call/n1/retR, which started with its
       definitions. */
  }
#endif // #if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
/*  End of !REPLACEMENT-tail-call/n1/retR , a replacement specialised instruction */

  /* Ordinary specialised instruction !REPLACEMENT-tail-call/n2/retR (replacement) */
  /* Omit this specialised instruction altogether unless
     replacements are in fact supported in this
     configuration. */
#if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
  JITTER_INSTRUCTION_PROLOG_(!REPLACEMENT-tail-call/n2/retR, _eREPLACEMENT_mtail_mcall__n2__retR, cold)
  { /* This block begins with definitions for !REPLACEMENT-tail-call/n2/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       337
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         !REPLACEMENT-tail-call/n2/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "tail-call"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "!REPLACEMENT-tail-call/n2/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _eREPLACEMENT_mtail_mcall__n2__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement and a caller.
       Its 1-th argument, a literal, is the return address where to jump
       back after the procedure returns.  Branch-and-link
       functionality is enabled for this instruction. */
/* This instruction is non-relocatable: use branches which
   cannot ever generate defects. */
#   undef JITTER_BRANCH_AND_LINK
#   define JITTER_BRANCH_AND_LINK      _JITTER_BRANCH_AND_LINK_FALLBACK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   define JITTER_BRANCH_AND_LINK_WITH _JITTER_BRANCH_AND_LINK_WITH_FALLBACK
#   undef JITTER_BRANCH_FAST_AND_LINK
#   define JITTER_BRANCH_FAST_AND_LINK _JITTER_BRANCH_AND_LINK_FALLBACK

    /* This specialized instruction is returning, and non-relocatable. */
#   define JITTER_RETURN  _JITTER_RETURN_FALLBACK

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1

    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 2L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1


#ifdef JITTER_REPLICATE
/* When jumping to the non-relocatable part it is important not
   to use a fallback version of JITTER_COMPUTED_GOTO, in order to
   prevent GCC from tail-merging. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
    /* Jump to non-relocatable code. */
    JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);

    /* Here the residual arity is given as zero: it's too late to
       skip residuals, since we've already jumped and this code is
       unreachable.  The instruction pointer, if any, is advanced
       in the non-relocatable code. */
    JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-tail-call/n2/retR, _eREPLACEMENT_mtail_mcall__n2__retR, 0)

    /* Relocated code will jump to this label in non-relocated code. */
  JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
    JITTER_COMMENT_IN_ASM_("!REPLACEMENT-tail-call/n2/retR non-relocatable code");
#endif // #ifdef JITTER_REPLICATE
#if defined(JITTER_DISPATCH_NO_THREADING)             \
    && (! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)  \
        || /* is this a replacement? */ 1)
  /* We use the implicit argument at the end of the calling.
     instruction to discover the procedure return address. */
  const void * const _jitter_return_pointer
    __attribute__ ((unused)) = JITTER_ARGP1;
  /* And make it accessible to the user (who will usually call 
     JITTER_BRANCH_AND_LINK) thru a nice macro. */
# define _JITTER_RETURN_ADDRESS _jitter_return_pointer
#endif

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of !REPLACEMENT-tail-call/n2/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  no. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
//#if 0
  //fprintf (stderr, "Executing instruction %s..\n", "!REPLACEMENT-tail-call/n2/retR"); fflush (stderr);
  //fprintf (stderr, "Executing replacement instruction %s..\n", "!REPLACEMENT-tail-call/n2/retR"); fflush (stderr);
  //fprintf (stderr, "Executing non-relocatable instruction %s with JITTER_SPECIALIZED_INSTRUCTION_WORD_NO=%i..\n", "!REPLACEMENT-tail-call/n2/retR", (int) JITTER_SPECIALIZED_INSTRUCTION_WORD_NO); fflush (stderr);
  //fprintf (stderr, "Executing caller replcament: _JITTER_RETURN_ADDRESS is %p..\n", _JITTER_RETURN_ADDRESS); fflush (stderr);
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#undef JITTER_THIS_IS_A_REPLACEMENT
#define JITTER_THIS_IS_A_REPLACEMENT 1

    /* User code for !REPLACEMENT-tail-call/n2/retR . */
  {
/* User-specified code, user code block part: beginning. */

    const jitter_uint in_arity = JITTER_ARGN0;
    jitterlisp_object callee = JITTER_AT_DEPTH_MAINSTACK(in_arity);
    struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(callee);

    if (c->kind == jitterlisp_closure_type_compiled)
      {
        /* Extract the current return address from the return stack, to be
           reused.  Differently from non-tail calls, don't push anything on
           the return stack: the callee will overwrite the top with its
           current value, which is what we want. */
        jitterlispvm_program_point current_link
          = (jitterlispvm_program_point) JITTER_TOP_RETURNSTACK();

        /* Branch-and-relink to the native code, whose first instruction
           will be a prolog. */
        struct jitterlisp_compiled_closure *cc = & c->compiled;
        JITTER_BRANCH_AND_LINK_WITH(cc->first_program_point, current_link);
      }
    else
      {
        /* Unfortunately I cannot really tail-call from compiled code to
           interpreted code.  Instead I will call the interpreter as a C
           function and then return. */
        const struct jitterlisp_interpreted_closure *ic = & c->interpreted;

        /* Push an element on the main stack.  This way we can ensure that
           every actual is accessible thru memory in a contiguous array,
           even if the main stack is TOS-optimized.  Compute the address
           (on the main stack backing) where the actuals begin.

           Notice that the interpreted function we are calling is allowed
           to call into compiled code in its turn.  This is not a problem,
           as we are not moving stack pointers down until the call ends:
           the unused part of the main and return stacks is available to
           the callee. */
        JITTER_PUSH_UNSPECIFIED_MAINSTACK();
        jitterlisp_object *actuals
          // FIXME: add a stack operator to compute this address.
          = (& JITTER_UNDER_TOP_MAINSTACK()) - in_arity + 1;

        /* Call the interpreter. */
        jitterlisp_object interpretation_result
          = jitterlisp_call_interpreted (ic, actuals, in_arity);

        /* Remove as many elements as the in-arity plus one (the callee) from
           the stack, without affecting the top.  Unless JITTER_ARGN0 is
           residual this whole loops compiles to one instruction when the main
           stack is TOS-optimized, and doesn't touch memory. */
        int i;
        for (i = 0; i < in_arity + 1; i ++)
          JITTER_NIP_MAINSTACK();

        /* Now the stack is one element higher than it was before the call,
           containing the unspecified element at the top.  Replace it with
           the result.  Again this doesn't touch memory. */
        JITTER_TOP_MAINSTACK() = interpretation_result;

        /* Return to our original caller. */
        jitter_uint return_address = JITTER_TOP_RETURNSTACK();
        JITTER_DROP_RETURNSTACK();
        JITTER_RETURN(return_address);
      }
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for !REPLACEMENT-tail-call/n2/retR . */

  //fprintf (stderr, "..Executed replacement instruction %s\n", "!REPLACEMENT-tail-call/n2/retR");
  //fprintf (stderr, "..Executed instruction %s\n", "!REPLACEMENT-tail-call/n2/retR");
//#endif // #if 0
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
#ifdef JITTER_REPLICATE
  {
    /* Advance the instruction pointer, if any, to skip every
       residual but the last; branch back to replicated
       code. */
    const void *_jitter_back_to_replicated_code_pointer =
      JITTER_ARGP1;
    JITTER_SKIP_RESIDUALS_;
    goto * _jitter_back_to_replicated_code_pointer;
  }
#endif // #ifdef JITTER_REPLICATE

    /* Undefine the !REPLACEMENT-tail-call/n2/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#if    defined(JITTER_DISPATCH_NO_THREADING)         \
    && ! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)
# undef _JITTER_RETURN_ADDRESS
#endif

#ifndef JITTER_REPLICATE
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-tail-call/n2/retR, _eREPLACEMENT_mtail_mcall__n2__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#endif // #ifndef JITTER_REPLICATE
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for !REPLACEMENT-tail-call/n2/retR, which started with its
       definitions. */
  }
#endif // #if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
/*  End of !REPLACEMENT-tail-call/n2/retR , a replacement specialised instruction */

  /* Ordinary specialised instruction !REPLACEMENT-tail-call/n3/retR (replacement) */
  /* Omit this specialised instruction altogether unless
     replacements are in fact supported in this
     configuration. */
#if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
  JITTER_INSTRUCTION_PROLOG_(!REPLACEMENT-tail-call/n3/retR, _eREPLACEMENT_mtail_mcall__n3__retR, cold)
  { /* This block begins with definitions for !REPLACEMENT-tail-call/n3/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       338
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         !REPLACEMENT-tail-call/n3/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "tail-call"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "!REPLACEMENT-tail-call/n3/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _eREPLACEMENT_mtail_mcall__n3__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement and a caller.
       Its 1-th argument, a literal, is the return address where to jump
       back after the procedure returns.  Branch-and-link
       functionality is enabled for this instruction. */
/* This instruction is non-relocatable: use branches which
   cannot ever generate defects. */
#   undef JITTER_BRANCH_AND_LINK
#   define JITTER_BRANCH_AND_LINK      _JITTER_BRANCH_AND_LINK_FALLBACK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   define JITTER_BRANCH_AND_LINK_WITH _JITTER_BRANCH_AND_LINK_WITH_FALLBACK
#   undef JITTER_BRANCH_FAST_AND_LINK
#   define JITTER_BRANCH_FAST_AND_LINK _JITTER_BRANCH_AND_LINK_FALLBACK

    /* This specialized instruction is returning, and non-relocatable. */
#   define JITTER_RETURN  _JITTER_RETURN_FALLBACK

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1

    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 3L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1


#ifdef JITTER_REPLICATE
/* When jumping to the non-relocatable part it is important not
   to use a fallback version of JITTER_COMPUTED_GOTO, in order to
   prevent GCC from tail-merging. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
    /* Jump to non-relocatable code. */
    JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);

    /* Here the residual arity is given as zero: it's too late to
       skip residuals, since we've already jumped and this code is
       unreachable.  The instruction pointer, if any, is advanced
       in the non-relocatable code. */
    JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-tail-call/n3/retR, _eREPLACEMENT_mtail_mcall__n3__retR, 0)

    /* Relocated code will jump to this label in non-relocated code. */
  JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
    JITTER_COMMENT_IN_ASM_("!REPLACEMENT-tail-call/n3/retR non-relocatable code");
#endif // #ifdef JITTER_REPLICATE
#if defined(JITTER_DISPATCH_NO_THREADING)             \
    && (! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)  \
        || /* is this a replacement? */ 1)
  /* We use the implicit argument at the end of the calling.
     instruction to discover the procedure return address. */
  const void * const _jitter_return_pointer
    __attribute__ ((unused)) = JITTER_ARGP1;
  /* And make it accessible to the user (who will usually call 
     JITTER_BRANCH_AND_LINK) thru a nice macro. */
# define _JITTER_RETURN_ADDRESS _jitter_return_pointer
#endif

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of !REPLACEMENT-tail-call/n3/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  no. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
//#if 0
  //fprintf (stderr, "Executing instruction %s..\n", "!REPLACEMENT-tail-call/n3/retR"); fflush (stderr);
  //fprintf (stderr, "Executing replacement instruction %s..\n", "!REPLACEMENT-tail-call/n3/retR"); fflush (stderr);
  //fprintf (stderr, "Executing non-relocatable instruction %s with JITTER_SPECIALIZED_INSTRUCTION_WORD_NO=%i..\n", "!REPLACEMENT-tail-call/n3/retR", (int) JITTER_SPECIALIZED_INSTRUCTION_WORD_NO); fflush (stderr);
  //fprintf (stderr, "Executing caller replcament: _JITTER_RETURN_ADDRESS is %p..\n", _JITTER_RETURN_ADDRESS); fflush (stderr);
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#undef JITTER_THIS_IS_A_REPLACEMENT
#define JITTER_THIS_IS_A_REPLACEMENT 1

    /* User code for !REPLACEMENT-tail-call/n3/retR . */
  {
/* User-specified code, user code block part: beginning. */

    const jitter_uint in_arity = JITTER_ARGN0;
    jitterlisp_object callee = JITTER_AT_DEPTH_MAINSTACK(in_arity);
    struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(callee);

    if (c->kind == jitterlisp_closure_type_compiled)
      {
        /* Extract the current return address from the return stack, to be
           reused.  Differently from non-tail calls, don't push anything on
           the return stack: the callee will overwrite the top with its
           current value, which is what we want. */
        jitterlispvm_program_point current_link
          = (jitterlispvm_program_point) JITTER_TOP_RETURNSTACK();

        /* Branch-and-relink to the native code, whose first instruction
           will be a prolog. */
        struct jitterlisp_compiled_closure *cc = & c->compiled;
        JITTER_BRANCH_AND_LINK_WITH(cc->first_program_point, current_link);
      }
    else
      {
        /* Unfortunately I cannot really tail-call from compiled code to
           interpreted code.  Instead I will call the interpreter as a C
           function and then return. */
        const struct jitterlisp_interpreted_closure *ic = & c->interpreted;

        /* Push an element on the main stack.  This way we can ensure that
           every actual is accessible thru memory in a contiguous array,
           even if the main stack is TOS-optimized.  Compute the address
           (on the main stack backing) where the actuals begin.

           Notice that the interpreted function we are calling is allowed
           to call into compiled code in its turn.  This is not a problem,
           as we are not moving stack pointers down until the call ends:
           the unused part of the main and return stacks is available to
           the callee. */
        JITTER_PUSH_UNSPECIFIED_MAINSTACK();
        jitterlisp_object *actuals
          // FIXME: add a stack operator to compute this address.
          = (& JITTER_UNDER_TOP_MAINSTACK()) - in_arity + 1;

        /* Call the interpreter. */
        jitterlisp_object interpretation_result
          = jitterlisp_call_interpreted (ic, actuals, in_arity);

        /* Remove as many elements as the in-arity plus one (the callee) from
           the stack, without affecting the top.  Unless JITTER_ARGN0 is
           residual this whole loops compiles to one instruction when the main
           stack is TOS-optimized, and doesn't touch memory. */
        int i;
        for (i = 0; i < in_arity + 1; i ++)
          JITTER_NIP_MAINSTACK();

        /* Now the stack is one element higher than it was before the call,
           containing the unspecified element at the top.  Replace it with
           the result.  Again this doesn't touch memory. */
        JITTER_TOP_MAINSTACK() = interpretation_result;

        /* Return to our original caller. */
        jitter_uint return_address = JITTER_TOP_RETURNSTACK();
        JITTER_DROP_RETURNSTACK();
        JITTER_RETURN(return_address);
      }
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for !REPLACEMENT-tail-call/n3/retR . */

  //fprintf (stderr, "..Executed replacement instruction %s\n", "!REPLACEMENT-tail-call/n3/retR");
  //fprintf (stderr, "..Executed instruction %s\n", "!REPLACEMENT-tail-call/n3/retR");
//#endif // #if 0
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
#ifdef JITTER_REPLICATE
  {
    /* Advance the instruction pointer, if any, to skip every
       residual but the last; branch back to replicated
       code. */
    const void *_jitter_back_to_replicated_code_pointer =
      JITTER_ARGP1;
    JITTER_SKIP_RESIDUALS_;
    goto * _jitter_back_to_replicated_code_pointer;
  }
#endif // #ifdef JITTER_REPLICATE

    /* Undefine the !REPLACEMENT-tail-call/n3/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#if    defined(JITTER_DISPATCH_NO_THREADING)         \
    && ! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)
# undef _JITTER_RETURN_ADDRESS
#endif

#ifndef JITTER_REPLICATE
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-tail-call/n3/retR, _eREPLACEMENT_mtail_mcall__n3__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#endif // #ifndef JITTER_REPLICATE
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for !REPLACEMENT-tail-call/n3/retR, which started with its
       definitions. */
  }
#endif // #if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
/*  End of !REPLACEMENT-tail-call/n3/retR , a replacement specialised instruction */

  /* Ordinary specialised instruction !REPLACEMENT-tail-call/n4/retR (replacement) */
  /* Omit this specialised instruction altogether unless
     replacements are in fact supported in this
     configuration. */
#if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
  JITTER_INSTRUCTION_PROLOG_(!REPLACEMENT-tail-call/n4/retR, _eREPLACEMENT_mtail_mcall__n4__retR, cold)
  { /* This block begins with definitions for !REPLACEMENT-tail-call/n4/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       339
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         !REPLACEMENT-tail-call/n4/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "tail-call"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "!REPLACEMENT-tail-call/n4/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _eREPLACEMENT_mtail_mcall__n4__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement and a caller.
       Its 1-th argument, a literal, is the return address where to jump
       back after the procedure returns.  Branch-and-link
       functionality is enabled for this instruction. */
/* This instruction is non-relocatable: use branches which
   cannot ever generate defects. */
#   undef JITTER_BRANCH_AND_LINK
#   define JITTER_BRANCH_AND_LINK      _JITTER_BRANCH_AND_LINK_FALLBACK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   define JITTER_BRANCH_AND_LINK_WITH _JITTER_BRANCH_AND_LINK_WITH_FALLBACK
#   undef JITTER_BRANCH_FAST_AND_LINK
#   define JITTER_BRANCH_FAST_AND_LINK _JITTER_BRANCH_AND_LINK_FALLBACK

    /* This specialized instruction is returning, and non-relocatable. */
#   define JITTER_RETURN  _JITTER_RETURN_FALLBACK

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1

    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 4L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1


#ifdef JITTER_REPLICATE
/* When jumping to the non-relocatable part it is important not
   to use a fallback version of JITTER_COMPUTED_GOTO, in order to
   prevent GCC from tail-merging. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
    /* Jump to non-relocatable code. */
    JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);

    /* Here the residual arity is given as zero: it's too late to
       skip residuals, since we've already jumped and this code is
       unreachable.  The instruction pointer, if any, is advanced
       in the non-relocatable code. */
    JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-tail-call/n4/retR, _eREPLACEMENT_mtail_mcall__n4__retR, 0)

    /* Relocated code will jump to this label in non-relocated code. */
  JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
    JITTER_COMMENT_IN_ASM_("!REPLACEMENT-tail-call/n4/retR non-relocatable code");
#endif // #ifdef JITTER_REPLICATE
#if defined(JITTER_DISPATCH_NO_THREADING)             \
    && (! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)  \
        || /* is this a replacement? */ 1)
  /* We use the implicit argument at the end of the calling.
     instruction to discover the procedure return address. */
  const void * const _jitter_return_pointer
    __attribute__ ((unused)) = JITTER_ARGP1;
  /* And make it accessible to the user (who will usually call 
     JITTER_BRANCH_AND_LINK) thru a nice macro. */
# define _JITTER_RETURN_ADDRESS _jitter_return_pointer
#endif

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of !REPLACEMENT-tail-call/n4/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  no. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
//#if 0
  //fprintf (stderr, "Executing instruction %s..\n", "!REPLACEMENT-tail-call/n4/retR"); fflush (stderr);
  //fprintf (stderr, "Executing replacement instruction %s..\n", "!REPLACEMENT-tail-call/n4/retR"); fflush (stderr);
  //fprintf (stderr, "Executing non-relocatable instruction %s with JITTER_SPECIALIZED_INSTRUCTION_WORD_NO=%i..\n", "!REPLACEMENT-tail-call/n4/retR", (int) JITTER_SPECIALIZED_INSTRUCTION_WORD_NO); fflush (stderr);
  //fprintf (stderr, "Executing caller replcament: _JITTER_RETURN_ADDRESS is %p..\n", _JITTER_RETURN_ADDRESS); fflush (stderr);
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#undef JITTER_THIS_IS_A_REPLACEMENT
#define JITTER_THIS_IS_A_REPLACEMENT 1

    /* User code for !REPLACEMENT-tail-call/n4/retR . */
  {
/* User-specified code, user code block part: beginning. */

    const jitter_uint in_arity = JITTER_ARGN0;
    jitterlisp_object callee = JITTER_AT_DEPTH_MAINSTACK(in_arity);
    struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(callee);

    if (c->kind == jitterlisp_closure_type_compiled)
      {
        /* Extract the current return address from the return stack, to be
           reused.  Differently from non-tail calls, don't push anything on
           the return stack: the callee will overwrite the top with its
           current value, which is what we want. */
        jitterlispvm_program_point current_link
          = (jitterlispvm_program_point) JITTER_TOP_RETURNSTACK();

        /* Branch-and-relink to the native code, whose first instruction
           will be a prolog. */
        struct jitterlisp_compiled_closure *cc = & c->compiled;
        JITTER_BRANCH_AND_LINK_WITH(cc->first_program_point, current_link);
      }
    else
      {
        /* Unfortunately I cannot really tail-call from compiled code to
           interpreted code.  Instead I will call the interpreter as a C
           function and then return. */
        const struct jitterlisp_interpreted_closure *ic = & c->interpreted;

        /* Push an element on the main stack.  This way we can ensure that
           every actual is accessible thru memory in a contiguous array,
           even if the main stack is TOS-optimized.  Compute the address
           (on the main stack backing) where the actuals begin.

           Notice that the interpreted function we are calling is allowed
           to call into compiled code in its turn.  This is not a problem,
           as we are not moving stack pointers down until the call ends:
           the unused part of the main and return stacks is available to
           the callee. */
        JITTER_PUSH_UNSPECIFIED_MAINSTACK();
        jitterlisp_object *actuals
          // FIXME: add a stack operator to compute this address.
          = (& JITTER_UNDER_TOP_MAINSTACK()) - in_arity + 1;

        /* Call the interpreter. */
        jitterlisp_object interpretation_result
          = jitterlisp_call_interpreted (ic, actuals, in_arity);

        /* Remove as many elements as the in-arity plus one (the callee) from
           the stack, without affecting the top.  Unless JITTER_ARGN0 is
           residual this whole loops compiles to one instruction when the main
           stack is TOS-optimized, and doesn't touch memory. */
        int i;
        for (i = 0; i < in_arity + 1; i ++)
          JITTER_NIP_MAINSTACK();

        /* Now the stack is one element higher than it was before the call,
           containing the unspecified element at the top.  Replace it with
           the result.  Again this doesn't touch memory. */
        JITTER_TOP_MAINSTACK() = interpretation_result;

        /* Return to our original caller. */
        jitter_uint return_address = JITTER_TOP_RETURNSTACK();
        JITTER_DROP_RETURNSTACK();
        JITTER_RETURN(return_address);
      }
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for !REPLACEMENT-tail-call/n4/retR . */

  //fprintf (stderr, "..Executed replacement instruction %s\n", "!REPLACEMENT-tail-call/n4/retR");
  //fprintf (stderr, "..Executed instruction %s\n", "!REPLACEMENT-tail-call/n4/retR");
//#endif // #if 0
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
#ifdef JITTER_REPLICATE
  {
    /* Advance the instruction pointer, if any, to skip every
       residual but the last; branch back to replicated
       code. */
    const void *_jitter_back_to_replicated_code_pointer =
      JITTER_ARGP1;
    JITTER_SKIP_RESIDUALS_;
    goto * _jitter_back_to_replicated_code_pointer;
  }
#endif // #ifdef JITTER_REPLICATE

    /* Undefine the !REPLACEMENT-tail-call/n4/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#if    defined(JITTER_DISPATCH_NO_THREADING)         \
    && ! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)
# undef _JITTER_RETURN_ADDRESS
#endif

#ifndef JITTER_REPLICATE
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-tail-call/n4/retR, _eREPLACEMENT_mtail_mcall__n4__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#endif // #ifndef JITTER_REPLICATE
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for !REPLACEMENT-tail-call/n4/retR, which started with its
       definitions. */
  }
#endif // #if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
/*  End of !REPLACEMENT-tail-call/n4/retR , a replacement specialised instruction */

  /* Ordinary specialised instruction !REPLACEMENT-tail-call/n5/retR (replacement) */
  /* Omit this specialised instruction altogether unless
     replacements are in fact supported in this
     configuration. */
#if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
  JITTER_INSTRUCTION_PROLOG_(!REPLACEMENT-tail-call/n5/retR, _eREPLACEMENT_mtail_mcall__n5__retR, cold)
  { /* This block begins with definitions for !REPLACEMENT-tail-call/n5/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       340
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         !REPLACEMENT-tail-call/n5/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "tail-call"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "!REPLACEMENT-tail-call/n5/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _eREPLACEMENT_mtail_mcall__n5__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement and a caller.
       Its 1-th argument, a literal, is the return address where to jump
       back after the procedure returns.  Branch-and-link
       functionality is enabled for this instruction. */
/* This instruction is non-relocatable: use branches which
   cannot ever generate defects. */
#   undef JITTER_BRANCH_AND_LINK
#   define JITTER_BRANCH_AND_LINK      _JITTER_BRANCH_AND_LINK_FALLBACK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   define JITTER_BRANCH_AND_LINK_WITH _JITTER_BRANCH_AND_LINK_WITH_FALLBACK
#   undef JITTER_BRANCH_FAST_AND_LINK
#   define JITTER_BRANCH_FAST_AND_LINK _JITTER_BRANCH_AND_LINK_FALLBACK

    /* This specialized instruction is returning, and non-relocatable. */
#   define JITTER_RETURN  _JITTER_RETURN_FALLBACK

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1

    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 5L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1


#ifdef JITTER_REPLICATE
/* When jumping to the non-relocatable part it is important not
   to use a fallback version of JITTER_COMPUTED_GOTO, in order to
   prevent GCC from tail-merging. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
    /* Jump to non-relocatable code. */
    JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);

    /* Here the residual arity is given as zero: it's too late to
       skip residuals, since we've already jumped and this code is
       unreachable.  The instruction pointer, if any, is advanced
       in the non-relocatable code. */
    JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-tail-call/n5/retR, _eREPLACEMENT_mtail_mcall__n5__retR, 0)

    /* Relocated code will jump to this label in non-relocated code. */
  JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
    JITTER_COMMENT_IN_ASM_("!REPLACEMENT-tail-call/n5/retR non-relocatable code");
#endif // #ifdef JITTER_REPLICATE
#if defined(JITTER_DISPATCH_NO_THREADING)             \
    && (! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)  \
        || /* is this a replacement? */ 1)
  /* We use the implicit argument at the end of the calling.
     instruction to discover the procedure return address. */
  const void * const _jitter_return_pointer
    __attribute__ ((unused)) = JITTER_ARGP1;
  /* And make it accessible to the user (who will usually call 
     JITTER_BRANCH_AND_LINK) thru a nice macro. */
# define _JITTER_RETURN_ADDRESS _jitter_return_pointer
#endif

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of !REPLACEMENT-tail-call/n5/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  no. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
//#if 0
  //fprintf (stderr, "Executing instruction %s..\n", "!REPLACEMENT-tail-call/n5/retR"); fflush (stderr);
  //fprintf (stderr, "Executing replacement instruction %s..\n", "!REPLACEMENT-tail-call/n5/retR"); fflush (stderr);
  //fprintf (stderr, "Executing non-relocatable instruction %s with JITTER_SPECIALIZED_INSTRUCTION_WORD_NO=%i..\n", "!REPLACEMENT-tail-call/n5/retR", (int) JITTER_SPECIALIZED_INSTRUCTION_WORD_NO); fflush (stderr);
  //fprintf (stderr, "Executing caller replcament: _JITTER_RETURN_ADDRESS is %p..\n", _JITTER_RETURN_ADDRESS); fflush (stderr);
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#undef JITTER_THIS_IS_A_REPLACEMENT
#define JITTER_THIS_IS_A_REPLACEMENT 1

    /* User code for !REPLACEMENT-tail-call/n5/retR . */
  {
/* User-specified code, user code block part: beginning. */

    const jitter_uint in_arity = JITTER_ARGN0;
    jitterlisp_object callee = JITTER_AT_DEPTH_MAINSTACK(in_arity);
    struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(callee);

    if (c->kind == jitterlisp_closure_type_compiled)
      {
        /* Extract the current return address from the return stack, to be
           reused.  Differently from non-tail calls, don't push anything on
           the return stack: the callee will overwrite the top with its
           current value, which is what we want. */
        jitterlispvm_program_point current_link
          = (jitterlispvm_program_point) JITTER_TOP_RETURNSTACK();

        /* Branch-and-relink to the native code, whose first instruction
           will be a prolog. */
        struct jitterlisp_compiled_closure *cc = & c->compiled;
        JITTER_BRANCH_AND_LINK_WITH(cc->first_program_point, current_link);
      }
    else
      {
        /* Unfortunately I cannot really tail-call from compiled code to
           interpreted code.  Instead I will call the interpreter as a C
           function and then return. */
        const struct jitterlisp_interpreted_closure *ic = & c->interpreted;

        /* Push an element on the main stack.  This way we can ensure that
           every actual is accessible thru memory in a contiguous array,
           even if the main stack is TOS-optimized.  Compute the address
           (on the main stack backing) where the actuals begin.

           Notice that the interpreted function we are calling is allowed
           to call into compiled code in its turn.  This is not a problem,
           as we are not moving stack pointers down until the call ends:
           the unused part of the main and return stacks is available to
           the callee. */
        JITTER_PUSH_UNSPECIFIED_MAINSTACK();
        jitterlisp_object *actuals
          // FIXME: add a stack operator to compute this address.
          = (& JITTER_UNDER_TOP_MAINSTACK()) - in_arity + 1;

        /* Call the interpreter. */
        jitterlisp_object interpretation_result
          = jitterlisp_call_interpreted (ic, actuals, in_arity);

        /* Remove as many elements as the in-arity plus one (the callee) from
           the stack, without affecting the top.  Unless JITTER_ARGN0 is
           residual this whole loops compiles to one instruction when the main
           stack is TOS-optimized, and doesn't touch memory. */
        int i;
        for (i = 0; i < in_arity + 1; i ++)
          JITTER_NIP_MAINSTACK();

        /* Now the stack is one element higher than it was before the call,
           containing the unspecified element at the top.  Replace it with
           the result.  Again this doesn't touch memory. */
        JITTER_TOP_MAINSTACK() = interpretation_result;

        /* Return to our original caller. */
        jitter_uint return_address = JITTER_TOP_RETURNSTACK();
        JITTER_DROP_RETURNSTACK();
        JITTER_RETURN(return_address);
      }
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for !REPLACEMENT-tail-call/n5/retR . */

  //fprintf (stderr, "..Executed replacement instruction %s\n", "!REPLACEMENT-tail-call/n5/retR");
  //fprintf (stderr, "..Executed instruction %s\n", "!REPLACEMENT-tail-call/n5/retR");
//#endif // #if 0
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
#ifdef JITTER_REPLICATE
  {
    /* Advance the instruction pointer, if any, to skip every
       residual but the last; branch back to replicated
       code. */
    const void *_jitter_back_to_replicated_code_pointer =
      JITTER_ARGP1;
    JITTER_SKIP_RESIDUALS_;
    goto * _jitter_back_to_replicated_code_pointer;
  }
#endif // #ifdef JITTER_REPLICATE

    /* Undefine the !REPLACEMENT-tail-call/n5/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#if    defined(JITTER_DISPATCH_NO_THREADING)         \
    && ! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)
# undef _JITTER_RETURN_ADDRESS
#endif

#ifndef JITTER_REPLICATE
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-tail-call/n5/retR, _eREPLACEMENT_mtail_mcall__n5__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#endif // #ifndef JITTER_REPLICATE
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for !REPLACEMENT-tail-call/n5/retR, which started with its
       definitions. */
  }
#endif // #if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
/*  End of !REPLACEMENT-tail-call/n5/retR , a replacement specialised instruction */

  /* Ordinary specialised instruction !REPLACEMENT-tail-call/n6/retR (replacement) */
  /* Omit this specialised instruction altogether unless
     replacements are in fact supported in this
     configuration. */
#if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
  JITTER_INSTRUCTION_PROLOG_(!REPLACEMENT-tail-call/n6/retR, _eREPLACEMENT_mtail_mcall__n6__retR, cold)
  { /* This block begins with definitions for !REPLACEMENT-tail-call/n6/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       341
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         !REPLACEMENT-tail-call/n6/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "tail-call"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "!REPLACEMENT-tail-call/n6/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _eREPLACEMENT_mtail_mcall__n6__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement and a caller.
       Its 1-th argument, a literal, is the return address where to jump
       back after the procedure returns.  Branch-and-link
       functionality is enabled for this instruction. */
/* This instruction is non-relocatable: use branches which
   cannot ever generate defects. */
#   undef JITTER_BRANCH_AND_LINK
#   define JITTER_BRANCH_AND_LINK      _JITTER_BRANCH_AND_LINK_FALLBACK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   define JITTER_BRANCH_AND_LINK_WITH _JITTER_BRANCH_AND_LINK_WITH_FALLBACK
#   undef JITTER_BRANCH_FAST_AND_LINK
#   define JITTER_BRANCH_FAST_AND_LINK _JITTER_BRANCH_AND_LINK_FALLBACK

    /* This specialized instruction is returning, and non-relocatable. */
#   define JITTER_RETURN  _JITTER_RETURN_FALLBACK

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1

    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 6L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1


#ifdef JITTER_REPLICATE
/* When jumping to the non-relocatable part it is important not
   to use a fallback version of JITTER_COMPUTED_GOTO, in order to
   prevent GCC from tail-merging. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
    /* Jump to non-relocatable code. */
    JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);

    /* Here the residual arity is given as zero: it's too late to
       skip residuals, since we've already jumped and this code is
       unreachable.  The instruction pointer, if any, is advanced
       in the non-relocatable code. */
    JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-tail-call/n6/retR, _eREPLACEMENT_mtail_mcall__n6__retR, 0)

    /* Relocated code will jump to this label in non-relocated code. */
  JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
    JITTER_COMMENT_IN_ASM_("!REPLACEMENT-tail-call/n6/retR non-relocatable code");
#endif // #ifdef JITTER_REPLICATE
#if defined(JITTER_DISPATCH_NO_THREADING)             \
    && (! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)  \
        || /* is this a replacement? */ 1)
  /* We use the implicit argument at the end of the calling.
     instruction to discover the procedure return address. */
  const void * const _jitter_return_pointer
    __attribute__ ((unused)) = JITTER_ARGP1;
  /* And make it accessible to the user (who will usually call 
     JITTER_BRANCH_AND_LINK) thru a nice macro. */
# define _JITTER_RETURN_ADDRESS _jitter_return_pointer
#endif

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of !REPLACEMENT-tail-call/n6/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  no. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
//#if 0
  //fprintf (stderr, "Executing instruction %s..\n", "!REPLACEMENT-tail-call/n6/retR"); fflush (stderr);
  //fprintf (stderr, "Executing replacement instruction %s..\n", "!REPLACEMENT-tail-call/n6/retR"); fflush (stderr);
  //fprintf (stderr, "Executing non-relocatable instruction %s with JITTER_SPECIALIZED_INSTRUCTION_WORD_NO=%i..\n", "!REPLACEMENT-tail-call/n6/retR", (int) JITTER_SPECIALIZED_INSTRUCTION_WORD_NO); fflush (stderr);
  //fprintf (stderr, "Executing caller replcament: _JITTER_RETURN_ADDRESS is %p..\n", _JITTER_RETURN_ADDRESS); fflush (stderr);
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#undef JITTER_THIS_IS_A_REPLACEMENT
#define JITTER_THIS_IS_A_REPLACEMENT 1

    /* User code for !REPLACEMENT-tail-call/n6/retR . */
  {
/* User-specified code, user code block part: beginning. */

    const jitter_uint in_arity = JITTER_ARGN0;
    jitterlisp_object callee = JITTER_AT_DEPTH_MAINSTACK(in_arity);
    struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(callee);

    if (c->kind == jitterlisp_closure_type_compiled)
      {
        /* Extract the current return address from the return stack, to be
           reused.  Differently from non-tail calls, don't push anything on
           the return stack: the callee will overwrite the top with its
           current value, which is what we want. */
        jitterlispvm_program_point current_link
          = (jitterlispvm_program_point) JITTER_TOP_RETURNSTACK();

        /* Branch-and-relink to the native code, whose first instruction
           will be a prolog. */
        struct jitterlisp_compiled_closure *cc = & c->compiled;
        JITTER_BRANCH_AND_LINK_WITH(cc->first_program_point, current_link);
      }
    else
      {
        /* Unfortunately I cannot really tail-call from compiled code to
           interpreted code.  Instead I will call the interpreter as a C
           function and then return. */
        const struct jitterlisp_interpreted_closure *ic = & c->interpreted;

        /* Push an element on the main stack.  This way we can ensure that
           every actual is accessible thru memory in a contiguous array,
           even if the main stack is TOS-optimized.  Compute the address
           (on the main stack backing) where the actuals begin.

           Notice that the interpreted function we are calling is allowed
           to call into compiled code in its turn.  This is not a problem,
           as we are not moving stack pointers down until the call ends:
           the unused part of the main and return stacks is available to
           the callee. */
        JITTER_PUSH_UNSPECIFIED_MAINSTACK();
        jitterlisp_object *actuals
          // FIXME: add a stack operator to compute this address.
          = (& JITTER_UNDER_TOP_MAINSTACK()) - in_arity + 1;

        /* Call the interpreter. */
        jitterlisp_object interpretation_result
          = jitterlisp_call_interpreted (ic, actuals, in_arity);

        /* Remove as many elements as the in-arity plus one (the callee) from
           the stack, without affecting the top.  Unless JITTER_ARGN0 is
           residual this whole loops compiles to one instruction when the main
           stack is TOS-optimized, and doesn't touch memory. */
        int i;
        for (i = 0; i < in_arity + 1; i ++)
          JITTER_NIP_MAINSTACK();

        /* Now the stack is one element higher than it was before the call,
           containing the unspecified element at the top.  Replace it with
           the result.  Again this doesn't touch memory. */
        JITTER_TOP_MAINSTACK() = interpretation_result;

        /* Return to our original caller. */
        jitter_uint return_address = JITTER_TOP_RETURNSTACK();
        JITTER_DROP_RETURNSTACK();
        JITTER_RETURN(return_address);
      }
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for !REPLACEMENT-tail-call/n6/retR . */

  //fprintf (stderr, "..Executed replacement instruction %s\n", "!REPLACEMENT-tail-call/n6/retR");
  //fprintf (stderr, "..Executed instruction %s\n", "!REPLACEMENT-tail-call/n6/retR");
//#endif // #if 0
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
#ifdef JITTER_REPLICATE
  {
    /* Advance the instruction pointer, if any, to skip every
       residual but the last; branch back to replicated
       code. */
    const void *_jitter_back_to_replicated_code_pointer =
      JITTER_ARGP1;
    JITTER_SKIP_RESIDUALS_;
    goto * _jitter_back_to_replicated_code_pointer;
  }
#endif // #ifdef JITTER_REPLICATE

    /* Undefine the !REPLACEMENT-tail-call/n6/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#if    defined(JITTER_DISPATCH_NO_THREADING)         \
    && ! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)
# undef _JITTER_RETURN_ADDRESS
#endif

#ifndef JITTER_REPLICATE
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-tail-call/n6/retR, _eREPLACEMENT_mtail_mcall__n6__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#endif // #ifndef JITTER_REPLICATE
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for !REPLACEMENT-tail-call/n6/retR, which started with its
       definitions. */
  }
#endif // #if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
/*  End of !REPLACEMENT-tail-call/n6/retR , a replacement specialised instruction */

  /* Ordinary specialised instruction !REPLACEMENT-tail-call/n7/retR (replacement) */
  /* Omit this specialised instruction altogether unless
     replacements are in fact supported in this
     configuration. */
#if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
  JITTER_INSTRUCTION_PROLOG_(!REPLACEMENT-tail-call/n7/retR, _eREPLACEMENT_mtail_mcall__n7__retR, cold)
  { /* This block begins with definitions for !REPLACEMENT-tail-call/n7/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       342
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         !REPLACEMENT-tail-call/n7/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "tail-call"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "!REPLACEMENT-tail-call/n7/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _eREPLACEMENT_mtail_mcall__n7__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement and a caller.
       Its 1-th argument, a literal, is the return address where to jump
       back after the procedure returns.  Branch-and-link
       functionality is enabled for this instruction. */
/* This instruction is non-relocatable: use branches which
   cannot ever generate defects. */
#   undef JITTER_BRANCH_AND_LINK
#   define JITTER_BRANCH_AND_LINK      _JITTER_BRANCH_AND_LINK_FALLBACK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   define JITTER_BRANCH_AND_LINK_WITH _JITTER_BRANCH_AND_LINK_WITH_FALLBACK
#   undef JITTER_BRANCH_FAST_AND_LINK
#   define JITTER_BRANCH_FAST_AND_LINK _JITTER_BRANCH_AND_LINK_FALLBACK

    /* This specialized instruction is returning, and non-relocatable. */
#   define JITTER_RETURN  _JITTER_RETURN_FALLBACK

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1

    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 7L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1


#ifdef JITTER_REPLICATE
/* When jumping to the non-relocatable part it is important not
   to use a fallback version of JITTER_COMPUTED_GOTO, in order to
   prevent GCC from tail-merging. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
    /* Jump to non-relocatable code. */
    JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);

    /* Here the residual arity is given as zero: it's too late to
       skip residuals, since we've already jumped and this code is
       unreachable.  The instruction pointer, if any, is advanced
       in the non-relocatable code. */
    JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-tail-call/n7/retR, _eREPLACEMENT_mtail_mcall__n7__retR, 0)

    /* Relocated code will jump to this label in non-relocated code. */
  JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
    JITTER_COMMENT_IN_ASM_("!REPLACEMENT-tail-call/n7/retR non-relocatable code");
#endif // #ifdef JITTER_REPLICATE
#if defined(JITTER_DISPATCH_NO_THREADING)             \
    && (! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)  \
        || /* is this a replacement? */ 1)
  /* We use the implicit argument at the end of the calling.
     instruction to discover the procedure return address. */
  const void * const _jitter_return_pointer
    __attribute__ ((unused)) = JITTER_ARGP1;
  /* And make it accessible to the user (who will usually call 
     JITTER_BRANCH_AND_LINK) thru a nice macro. */
# define _JITTER_RETURN_ADDRESS _jitter_return_pointer
#endif

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of !REPLACEMENT-tail-call/n7/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  no. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
//#if 0
  //fprintf (stderr, "Executing instruction %s..\n", "!REPLACEMENT-tail-call/n7/retR"); fflush (stderr);
  //fprintf (stderr, "Executing replacement instruction %s..\n", "!REPLACEMENT-tail-call/n7/retR"); fflush (stderr);
  //fprintf (stderr, "Executing non-relocatable instruction %s with JITTER_SPECIALIZED_INSTRUCTION_WORD_NO=%i..\n", "!REPLACEMENT-tail-call/n7/retR", (int) JITTER_SPECIALIZED_INSTRUCTION_WORD_NO); fflush (stderr);
  //fprintf (stderr, "Executing caller replcament: _JITTER_RETURN_ADDRESS is %p..\n", _JITTER_RETURN_ADDRESS); fflush (stderr);
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#undef JITTER_THIS_IS_A_REPLACEMENT
#define JITTER_THIS_IS_A_REPLACEMENT 1

    /* User code for !REPLACEMENT-tail-call/n7/retR . */
  {
/* User-specified code, user code block part: beginning. */

    const jitter_uint in_arity = JITTER_ARGN0;
    jitterlisp_object callee = JITTER_AT_DEPTH_MAINSTACK(in_arity);
    struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(callee);

    if (c->kind == jitterlisp_closure_type_compiled)
      {
        /* Extract the current return address from the return stack, to be
           reused.  Differently from non-tail calls, don't push anything on
           the return stack: the callee will overwrite the top with its
           current value, which is what we want. */
        jitterlispvm_program_point current_link
          = (jitterlispvm_program_point) JITTER_TOP_RETURNSTACK();

        /* Branch-and-relink to the native code, whose first instruction
           will be a prolog. */
        struct jitterlisp_compiled_closure *cc = & c->compiled;
        JITTER_BRANCH_AND_LINK_WITH(cc->first_program_point, current_link);
      }
    else
      {
        /* Unfortunately I cannot really tail-call from compiled code to
           interpreted code.  Instead I will call the interpreter as a C
           function and then return. */
        const struct jitterlisp_interpreted_closure *ic = & c->interpreted;

        /* Push an element on the main stack.  This way we can ensure that
           every actual is accessible thru memory in a contiguous array,
           even if the main stack is TOS-optimized.  Compute the address
           (on the main stack backing) where the actuals begin.

           Notice that the interpreted function we are calling is allowed
           to call into compiled code in its turn.  This is not a problem,
           as we are not moving stack pointers down until the call ends:
           the unused part of the main and return stacks is available to
           the callee. */
        JITTER_PUSH_UNSPECIFIED_MAINSTACK();
        jitterlisp_object *actuals
          // FIXME: add a stack operator to compute this address.
          = (& JITTER_UNDER_TOP_MAINSTACK()) - in_arity + 1;

        /* Call the interpreter. */
        jitterlisp_object interpretation_result
          = jitterlisp_call_interpreted (ic, actuals, in_arity);

        /* Remove as many elements as the in-arity plus one (the callee) from
           the stack, without affecting the top.  Unless JITTER_ARGN0 is
           residual this whole loops compiles to one instruction when the main
           stack is TOS-optimized, and doesn't touch memory. */
        int i;
        for (i = 0; i < in_arity + 1; i ++)
          JITTER_NIP_MAINSTACK();

        /* Now the stack is one element higher than it was before the call,
           containing the unspecified element at the top.  Replace it with
           the result.  Again this doesn't touch memory. */
        JITTER_TOP_MAINSTACK() = interpretation_result;

        /* Return to our original caller. */
        jitter_uint return_address = JITTER_TOP_RETURNSTACK();
        JITTER_DROP_RETURNSTACK();
        JITTER_RETURN(return_address);
      }
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for !REPLACEMENT-tail-call/n7/retR . */

  //fprintf (stderr, "..Executed replacement instruction %s\n", "!REPLACEMENT-tail-call/n7/retR");
  //fprintf (stderr, "..Executed instruction %s\n", "!REPLACEMENT-tail-call/n7/retR");
//#endif // #if 0
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
#ifdef JITTER_REPLICATE
  {
    /* Advance the instruction pointer, if any, to skip every
       residual but the last; branch back to replicated
       code. */
    const void *_jitter_back_to_replicated_code_pointer =
      JITTER_ARGP1;
    JITTER_SKIP_RESIDUALS_;
    goto * _jitter_back_to_replicated_code_pointer;
  }
#endif // #ifdef JITTER_REPLICATE

    /* Undefine the !REPLACEMENT-tail-call/n7/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#if    defined(JITTER_DISPATCH_NO_THREADING)         \
    && ! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)
# undef _JITTER_RETURN_ADDRESS
#endif

#ifndef JITTER_REPLICATE
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-tail-call/n7/retR, _eREPLACEMENT_mtail_mcall__n7__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#endif // #ifndef JITTER_REPLICATE
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for !REPLACEMENT-tail-call/n7/retR, which started with its
       definitions. */
  }
#endif // #if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
/*  End of !REPLACEMENT-tail-call/n7/retR , a replacement specialised instruction */

  /* Ordinary specialised instruction !REPLACEMENT-tail-call/n8/retR (replacement) */
  /* Omit this specialised instruction altogether unless
     replacements are in fact supported in this
     configuration. */
#if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
  JITTER_INSTRUCTION_PROLOG_(!REPLACEMENT-tail-call/n8/retR, _eREPLACEMENT_mtail_mcall__n8__retR, cold)
  { /* This block begins with definitions for !REPLACEMENT-tail-call/n8/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       343
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         !REPLACEMENT-tail-call/n8/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "tail-call"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "!REPLACEMENT-tail-call/n8/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _eREPLACEMENT_mtail_mcall__n8__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement and a caller.
       Its 1-th argument, a literal, is the return address where to jump
       back after the procedure returns.  Branch-and-link
       functionality is enabled for this instruction. */
/* This instruction is non-relocatable: use branches which
   cannot ever generate defects. */
#   undef JITTER_BRANCH_AND_LINK
#   define JITTER_BRANCH_AND_LINK      _JITTER_BRANCH_AND_LINK_FALLBACK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   define JITTER_BRANCH_AND_LINK_WITH _JITTER_BRANCH_AND_LINK_WITH_FALLBACK
#   undef JITTER_BRANCH_FAST_AND_LINK
#   define JITTER_BRANCH_FAST_AND_LINK _JITTER_BRANCH_AND_LINK_FALLBACK

    /* This specialized instruction is returning, and non-relocatable. */
#   define JITTER_RETURN  _JITTER_RETURN_FALLBACK

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1

    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 8L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1


#ifdef JITTER_REPLICATE
/* When jumping to the non-relocatable part it is important not
   to use a fallback version of JITTER_COMPUTED_GOTO, in order to
   prevent GCC from tail-merging. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
    /* Jump to non-relocatable code. */
    JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);

    /* Here the residual arity is given as zero: it's too late to
       skip residuals, since we've already jumped and this code is
       unreachable.  The instruction pointer, if any, is advanced
       in the non-relocatable code. */
    JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-tail-call/n8/retR, _eREPLACEMENT_mtail_mcall__n8__retR, 0)

    /* Relocated code will jump to this label in non-relocated code. */
  JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
    JITTER_COMMENT_IN_ASM_("!REPLACEMENT-tail-call/n8/retR non-relocatable code");
#endif // #ifdef JITTER_REPLICATE
#if defined(JITTER_DISPATCH_NO_THREADING)             \
    && (! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)  \
        || /* is this a replacement? */ 1)
  /* We use the implicit argument at the end of the calling.
     instruction to discover the procedure return address. */
  const void * const _jitter_return_pointer
    __attribute__ ((unused)) = JITTER_ARGP1;
  /* And make it accessible to the user (who will usually call 
     JITTER_BRANCH_AND_LINK) thru a nice macro. */
# define _JITTER_RETURN_ADDRESS _jitter_return_pointer
#endif

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of !REPLACEMENT-tail-call/n8/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  no. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
//#if 0
  //fprintf (stderr, "Executing instruction %s..\n", "!REPLACEMENT-tail-call/n8/retR"); fflush (stderr);
  //fprintf (stderr, "Executing replacement instruction %s..\n", "!REPLACEMENT-tail-call/n8/retR"); fflush (stderr);
  //fprintf (stderr, "Executing non-relocatable instruction %s with JITTER_SPECIALIZED_INSTRUCTION_WORD_NO=%i..\n", "!REPLACEMENT-tail-call/n8/retR", (int) JITTER_SPECIALIZED_INSTRUCTION_WORD_NO); fflush (stderr);
  //fprintf (stderr, "Executing caller replcament: _JITTER_RETURN_ADDRESS is %p..\n", _JITTER_RETURN_ADDRESS); fflush (stderr);
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#undef JITTER_THIS_IS_A_REPLACEMENT
#define JITTER_THIS_IS_A_REPLACEMENT 1

    /* User code for !REPLACEMENT-tail-call/n8/retR . */
  {
/* User-specified code, user code block part: beginning. */

    const jitter_uint in_arity = JITTER_ARGN0;
    jitterlisp_object callee = JITTER_AT_DEPTH_MAINSTACK(in_arity);
    struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(callee);

    if (c->kind == jitterlisp_closure_type_compiled)
      {
        /* Extract the current return address from the return stack, to be
           reused.  Differently from non-tail calls, don't push anything on
           the return stack: the callee will overwrite the top with its
           current value, which is what we want. */
        jitterlispvm_program_point current_link
          = (jitterlispvm_program_point) JITTER_TOP_RETURNSTACK();

        /* Branch-and-relink to the native code, whose first instruction
           will be a prolog. */
        struct jitterlisp_compiled_closure *cc = & c->compiled;
        JITTER_BRANCH_AND_LINK_WITH(cc->first_program_point, current_link);
      }
    else
      {
        /* Unfortunately I cannot really tail-call from compiled code to
           interpreted code.  Instead I will call the interpreter as a C
           function and then return. */
        const struct jitterlisp_interpreted_closure *ic = & c->interpreted;

        /* Push an element on the main stack.  This way we can ensure that
           every actual is accessible thru memory in a contiguous array,
           even if the main stack is TOS-optimized.  Compute the address
           (on the main stack backing) where the actuals begin.

           Notice that the interpreted function we are calling is allowed
           to call into compiled code in its turn.  This is not a problem,
           as we are not moving stack pointers down until the call ends:
           the unused part of the main and return stacks is available to
           the callee. */
        JITTER_PUSH_UNSPECIFIED_MAINSTACK();
        jitterlisp_object *actuals
          // FIXME: add a stack operator to compute this address.
          = (& JITTER_UNDER_TOP_MAINSTACK()) - in_arity + 1;

        /* Call the interpreter. */
        jitterlisp_object interpretation_result
          = jitterlisp_call_interpreted (ic, actuals, in_arity);

        /* Remove as many elements as the in-arity plus one (the callee) from
           the stack, without affecting the top.  Unless JITTER_ARGN0 is
           residual this whole loops compiles to one instruction when the main
           stack is TOS-optimized, and doesn't touch memory. */
        int i;
        for (i = 0; i < in_arity + 1; i ++)
          JITTER_NIP_MAINSTACK();

        /* Now the stack is one element higher than it was before the call,
           containing the unspecified element at the top.  Replace it with
           the result.  Again this doesn't touch memory. */
        JITTER_TOP_MAINSTACK() = interpretation_result;

        /* Return to our original caller. */
        jitter_uint return_address = JITTER_TOP_RETURNSTACK();
        JITTER_DROP_RETURNSTACK();
        JITTER_RETURN(return_address);
      }
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for !REPLACEMENT-tail-call/n8/retR . */

  //fprintf (stderr, "..Executed replacement instruction %s\n", "!REPLACEMENT-tail-call/n8/retR");
  //fprintf (stderr, "..Executed instruction %s\n", "!REPLACEMENT-tail-call/n8/retR");
//#endif // #if 0
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
#ifdef JITTER_REPLICATE
  {
    /* Advance the instruction pointer, if any, to skip every
       residual but the last; branch back to replicated
       code. */
    const void *_jitter_back_to_replicated_code_pointer =
      JITTER_ARGP1;
    JITTER_SKIP_RESIDUALS_;
    goto * _jitter_back_to_replicated_code_pointer;
  }
#endif // #ifdef JITTER_REPLICATE

    /* Undefine the !REPLACEMENT-tail-call/n8/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#if    defined(JITTER_DISPATCH_NO_THREADING)         \
    && ! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)
# undef _JITTER_RETURN_ADDRESS
#endif

#ifndef JITTER_REPLICATE
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-tail-call/n8/retR, _eREPLACEMENT_mtail_mcall__n8__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#endif // #ifndef JITTER_REPLICATE
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for !REPLACEMENT-tail-call/n8/retR, which started with its
       definitions. */
  }
#endif // #if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
/*  End of !REPLACEMENT-tail-call/n8/retR , a replacement specialised instruction */

  /* Ordinary specialised instruction !REPLACEMENT-tail-call/n9/retR (replacement) */
  /* Omit this specialised instruction altogether unless
     replacements are in fact supported in this
     configuration. */
#if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
  JITTER_INSTRUCTION_PROLOG_(!REPLACEMENT-tail-call/n9/retR, _eREPLACEMENT_mtail_mcall__n9__retR, cold)
  { /* This block begins with definitions for !REPLACEMENT-tail-call/n9/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       344
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         !REPLACEMENT-tail-call/n9/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "tail-call"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "!REPLACEMENT-tail-call/n9/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _eREPLACEMENT_mtail_mcall__n9__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement and a caller.
       Its 1-th argument, a literal, is the return address where to jump
       back after the procedure returns.  Branch-and-link
       functionality is enabled for this instruction. */
/* This instruction is non-relocatable: use branches which
   cannot ever generate defects. */
#   undef JITTER_BRANCH_AND_LINK
#   define JITTER_BRANCH_AND_LINK      _JITTER_BRANCH_AND_LINK_FALLBACK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   define JITTER_BRANCH_AND_LINK_WITH _JITTER_BRANCH_AND_LINK_WITH_FALLBACK
#   undef JITTER_BRANCH_FAST_AND_LINK
#   define JITTER_BRANCH_FAST_AND_LINK _JITTER_BRANCH_AND_LINK_FALLBACK

    /* This specialized instruction is returning, and non-relocatable. */
#   define JITTER_RETURN  _JITTER_RETURN_FALLBACK

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1

    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 9L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1


#ifdef JITTER_REPLICATE
/* When jumping to the non-relocatable part it is important not
   to use a fallback version of JITTER_COMPUTED_GOTO, in order to
   prevent GCC from tail-merging. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
    /* Jump to non-relocatable code. */
    JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);

    /* Here the residual arity is given as zero: it's too late to
       skip residuals, since we've already jumped and this code is
       unreachable.  The instruction pointer, if any, is advanced
       in the non-relocatable code. */
    JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-tail-call/n9/retR, _eREPLACEMENT_mtail_mcall__n9__retR, 0)

    /* Relocated code will jump to this label in non-relocated code. */
  JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
    JITTER_COMMENT_IN_ASM_("!REPLACEMENT-tail-call/n9/retR non-relocatable code");
#endif // #ifdef JITTER_REPLICATE
#if defined(JITTER_DISPATCH_NO_THREADING)             \
    && (! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)  \
        || /* is this a replacement? */ 1)
  /* We use the implicit argument at the end of the calling.
     instruction to discover the procedure return address. */
  const void * const _jitter_return_pointer
    __attribute__ ((unused)) = JITTER_ARGP1;
  /* And make it accessible to the user (who will usually call 
     JITTER_BRANCH_AND_LINK) thru a nice macro. */
# define _JITTER_RETURN_ADDRESS _jitter_return_pointer
#endif

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of !REPLACEMENT-tail-call/n9/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  no. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
//#if 0
  //fprintf (stderr, "Executing instruction %s..\n", "!REPLACEMENT-tail-call/n9/retR"); fflush (stderr);
  //fprintf (stderr, "Executing replacement instruction %s..\n", "!REPLACEMENT-tail-call/n9/retR"); fflush (stderr);
  //fprintf (stderr, "Executing non-relocatable instruction %s with JITTER_SPECIALIZED_INSTRUCTION_WORD_NO=%i..\n", "!REPLACEMENT-tail-call/n9/retR", (int) JITTER_SPECIALIZED_INSTRUCTION_WORD_NO); fflush (stderr);
  //fprintf (stderr, "Executing caller replcament: _JITTER_RETURN_ADDRESS is %p..\n", _JITTER_RETURN_ADDRESS); fflush (stderr);
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#undef JITTER_THIS_IS_A_REPLACEMENT
#define JITTER_THIS_IS_A_REPLACEMENT 1

    /* User code for !REPLACEMENT-tail-call/n9/retR . */
  {
/* User-specified code, user code block part: beginning. */

    const jitter_uint in_arity = JITTER_ARGN0;
    jitterlisp_object callee = JITTER_AT_DEPTH_MAINSTACK(in_arity);
    struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(callee);

    if (c->kind == jitterlisp_closure_type_compiled)
      {
        /* Extract the current return address from the return stack, to be
           reused.  Differently from non-tail calls, don't push anything on
           the return stack: the callee will overwrite the top with its
           current value, which is what we want. */
        jitterlispvm_program_point current_link
          = (jitterlispvm_program_point) JITTER_TOP_RETURNSTACK();

        /* Branch-and-relink to the native code, whose first instruction
           will be a prolog. */
        struct jitterlisp_compiled_closure *cc = & c->compiled;
        JITTER_BRANCH_AND_LINK_WITH(cc->first_program_point, current_link);
      }
    else
      {
        /* Unfortunately I cannot really tail-call from compiled code to
           interpreted code.  Instead I will call the interpreter as a C
           function and then return. */
        const struct jitterlisp_interpreted_closure *ic = & c->interpreted;

        /* Push an element on the main stack.  This way we can ensure that
           every actual is accessible thru memory in a contiguous array,
           even if the main stack is TOS-optimized.  Compute the address
           (on the main stack backing) where the actuals begin.

           Notice that the interpreted function we are calling is allowed
           to call into compiled code in its turn.  This is not a problem,
           as we are not moving stack pointers down until the call ends:
           the unused part of the main and return stacks is available to
           the callee. */
        JITTER_PUSH_UNSPECIFIED_MAINSTACK();
        jitterlisp_object *actuals
          // FIXME: add a stack operator to compute this address.
          = (& JITTER_UNDER_TOP_MAINSTACK()) - in_arity + 1;

        /* Call the interpreter. */
        jitterlisp_object interpretation_result
          = jitterlisp_call_interpreted (ic, actuals, in_arity);

        /* Remove as many elements as the in-arity plus one (the callee) from
           the stack, without affecting the top.  Unless JITTER_ARGN0 is
           residual this whole loops compiles to one instruction when the main
           stack is TOS-optimized, and doesn't touch memory. */
        int i;
        for (i = 0; i < in_arity + 1; i ++)
          JITTER_NIP_MAINSTACK();

        /* Now the stack is one element higher than it was before the call,
           containing the unspecified element at the top.  Replace it with
           the result.  Again this doesn't touch memory. */
        JITTER_TOP_MAINSTACK() = interpretation_result;

        /* Return to our original caller. */
        jitter_uint return_address = JITTER_TOP_RETURNSTACK();
        JITTER_DROP_RETURNSTACK();
        JITTER_RETURN(return_address);
      }
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for !REPLACEMENT-tail-call/n9/retR . */

  //fprintf (stderr, "..Executed replacement instruction %s\n", "!REPLACEMENT-tail-call/n9/retR");
  //fprintf (stderr, "..Executed instruction %s\n", "!REPLACEMENT-tail-call/n9/retR");
//#endif // #if 0
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
#ifdef JITTER_REPLICATE
  {
    /* Advance the instruction pointer, if any, to skip every
       residual but the last; branch back to replicated
       code. */
    const void *_jitter_back_to_replicated_code_pointer =
      JITTER_ARGP1;
    JITTER_SKIP_RESIDUALS_;
    goto * _jitter_back_to_replicated_code_pointer;
  }
#endif // #ifdef JITTER_REPLICATE

    /* Undefine the !REPLACEMENT-tail-call/n9/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#if    defined(JITTER_DISPATCH_NO_THREADING)         \
    && ! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)
# undef _JITTER_RETURN_ADDRESS
#endif

#ifndef JITTER_REPLICATE
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-tail-call/n9/retR, _eREPLACEMENT_mtail_mcall__n9__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#endif // #ifndef JITTER_REPLICATE
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for !REPLACEMENT-tail-call/n9/retR, which started with its
       definitions. */
  }
#endif // #if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
/*  End of !REPLACEMENT-tail-call/n9/retR , a replacement specialised instruction */

  /* Ordinary specialised instruction !REPLACEMENT-tail-call/n10/retR (replacement) */
  /* Omit this specialised instruction altogether unless
     replacements are in fact supported in this
     configuration. */
#if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
  JITTER_INSTRUCTION_PROLOG_(!REPLACEMENT-tail-call/n10/retR, _eREPLACEMENT_mtail_mcall__n10__retR, cold)
  { /* This block begins with definitions for !REPLACEMENT-tail-call/n10/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       345
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         !REPLACEMENT-tail-call/n10/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "tail-call"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "!REPLACEMENT-tail-call/n10/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _eREPLACEMENT_mtail_mcall__n10__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement and a caller.
       Its 1-th argument, a literal, is the return address where to jump
       back after the procedure returns.  Branch-and-link
       functionality is enabled for this instruction. */
/* This instruction is non-relocatable: use branches which
   cannot ever generate defects. */
#   undef JITTER_BRANCH_AND_LINK
#   define JITTER_BRANCH_AND_LINK      _JITTER_BRANCH_AND_LINK_FALLBACK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   define JITTER_BRANCH_AND_LINK_WITH _JITTER_BRANCH_AND_LINK_WITH_FALLBACK
#   undef JITTER_BRANCH_FAST_AND_LINK
#   define JITTER_BRANCH_FAST_AND_LINK _JITTER_BRANCH_AND_LINK_FALLBACK

    /* This specialized instruction is returning, and non-relocatable. */
#   define JITTER_RETURN  _JITTER_RETURN_FALLBACK

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1

    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 10L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1


#ifdef JITTER_REPLICATE
/* When jumping to the non-relocatable part it is important not
   to use a fallback version of JITTER_COMPUTED_GOTO, in order to
   prevent GCC from tail-merging. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
    /* Jump to non-relocatable code. */
    JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);

    /* Here the residual arity is given as zero: it's too late to
       skip residuals, since we've already jumped and this code is
       unreachable.  The instruction pointer, if any, is advanced
       in the non-relocatable code. */
    JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-tail-call/n10/retR, _eREPLACEMENT_mtail_mcall__n10__retR, 0)

    /* Relocated code will jump to this label in non-relocated code. */
  JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
    JITTER_COMMENT_IN_ASM_("!REPLACEMENT-tail-call/n10/retR non-relocatable code");
#endif // #ifdef JITTER_REPLICATE
#if defined(JITTER_DISPATCH_NO_THREADING)             \
    && (! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)  \
        || /* is this a replacement? */ 1)
  /* We use the implicit argument at the end of the calling.
     instruction to discover the procedure return address. */
  const void * const _jitter_return_pointer
    __attribute__ ((unused)) = JITTER_ARGP1;
  /* And make it accessible to the user (who will usually call 
     JITTER_BRANCH_AND_LINK) thru a nice macro. */
# define _JITTER_RETURN_ADDRESS _jitter_return_pointer
#endif

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of !REPLACEMENT-tail-call/n10/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  no. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
//#if 0
  //fprintf (stderr, "Executing instruction %s..\n", "!REPLACEMENT-tail-call/n10/retR"); fflush (stderr);
  //fprintf (stderr, "Executing replacement instruction %s..\n", "!REPLACEMENT-tail-call/n10/retR"); fflush (stderr);
  //fprintf (stderr, "Executing non-relocatable instruction %s with JITTER_SPECIALIZED_INSTRUCTION_WORD_NO=%i..\n", "!REPLACEMENT-tail-call/n10/retR", (int) JITTER_SPECIALIZED_INSTRUCTION_WORD_NO); fflush (stderr);
  //fprintf (stderr, "Executing caller replcament: _JITTER_RETURN_ADDRESS is %p..\n", _JITTER_RETURN_ADDRESS); fflush (stderr);
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#undef JITTER_THIS_IS_A_REPLACEMENT
#define JITTER_THIS_IS_A_REPLACEMENT 1

    /* User code for !REPLACEMENT-tail-call/n10/retR . */
  {
/* User-specified code, user code block part: beginning. */

    const jitter_uint in_arity = JITTER_ARGN0;
    jitterlisp_object callee = JITTER_AT_DEPTH_MAINSTACK(in_arity);
    struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(callee);

    if (c->kind == jitterlisp_closure_type_compiled)
      {
        /* Extract the current return address from the return stack, to be
           reused.  Differently from non-tail calls, don't push anything on
           the return stack: the callee will overwrite the top with its
           current value, which is what we want. */
        jitterlispvm_program_point current_link
          = (jitterlispvm_program_point) JITTER_TOP_RETURNSTACK();

        /* Branch-and-relink to the native code, whose first instruction
           will be a prolog. */
        struct jitterlisp_compiled_closure *cc = & c->compiled;
        JITTER_BRANCH_AND_LINK_WITH(cc->first_program_point, current_link);
      }
    else
      {
        /* Unfortunately I cannot really tail-call from compiled code to
           interpreted code.  Instead I will call the interpreter as a C
           function and then return. */
        const struct jitterlisp_interpreted_closure *ic = & c->interpreted;

        /* Push an element on the main stack.  This way we can ensure that
           every actual is accessible thru memory in a contiguous array,
           even if the main stack is TOS-optimized.  Compute the address
           (on the main stack backing) where the actuals begin.

           Notice that the interpreted function we are calling is allowed
           to call into compiled code in its turn.  This is not a problem,
           as we are not moving stack pointers down until the call ends:
           the unused part of the main and return stacks is available to
           the callee. */
        JITTER_PUSH_UNSPECIFIED_MAINSTACK();
        jitterlisp_object *actuals
          // FIXME: add a stack operator to compute this address.
          = (& JITTER_UNDER_TOP_MAINSTACK()) - in_arity + 1;

        /* Call the interpreter. */
        jitterlisp_object interpretation_result
          = jitterlisp_call_interpreted (ic, actuals, in_arity);

        /* Remove as many elements as the in-arity plus one (the callee) from
           the stack, without affecting the top.  Unless JITTER_ARGN0 is
           residual this whole loops compiles to one instruction when the main
           stack is TOS-optimized, and doesn't touch memory. */
        int i;
        for (i = 0; i < in_arity + 1; i ++)
          JITTER_NIP_MAINSTACK();

        /* Now the stack is one element higher than it was before the call,
           containing the unspecified element at the top.  Replace it with
           the result.  Again this doesn't touch memory. */
        JITTER_TOP_MAINSTACK() = interpretation_result;

        /* Return to our original caller. */
        jitter_uint return_address = JITTER_TOP_RETURNSTACK();
        JITTER_DROP_RETURNSTACK();
        JITTER_RETURN(return_address);
      }
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for !REPLACEMENT-tail-call/n10/retR . */

  //fprintf (stderr, "..Executed replacement instruction %s\n", "!REPLACEMENT-tail-call/n10/retR");
  //fprintf (stderr, "..Executed instruction %s\n", "!REPLACEMENT-tail-call/n10/retR");
//#endif // #if 0
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
#ifdef JITTER_REPLICATE
  {
    /* Advance the instruction pointer, if any, to skip every
       residual but the last; branch back to replicated
       code. */
    const void *_jitter_back_to_replicated_code_pointer =
      JITTER_ARGP1;
    JITTER_SKIP_RESIDUALS_;
    goto * _jitter_back_to_replicated_code_pointer;
  }
#endif // #ifdef JITTER_REPLICATE

    /* Undefine the !REPLACEMENT-tail-call/n10/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#if    defined(JITTER_DISPATCH_NO_THREADING)         \
    && ! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)
# undef _JITTER_RETURN_ADDRESS
#endif

#ifndef JITTER_REPLICATE
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-tail-call/n10/retR, _eREPLACEMENT_mtail_mcall__n10__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#endif // #ifndef JITTER_REPLICATE
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for !REPLACEMENT-tail-call/n10/retR, which started with its
       definitions. */
  }
#endif // #if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
/*  End of !REPLACEMENT-tail-call/n10/retR , a replacement specialised instruction */

  /* Ordinary specialised instruction !REPLACEMENT-tail-call/nR/retR (replacement) */
  /* Omit this specialised instruction altogether unless
     replacements are in fact supported in this
     configuration. */
#if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
  JITTER_INSTRUCTION_PROLOG_(!REPLACEMENT-tail-call/nR/retR, _eREPLACEMENT_mtail_mcall__nR__retR, cold)
  { /* This block begins with definitions for !REPLACEMENT-tail-call/nR/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       346
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         !REPLACEMENT-tail-call/nR/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "tail-call"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "!REPLACEMENT-tail-call/nR/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _eREPLACEMENT_mtail_mcall__nR__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement and a caller.
       Its 1-th argument, a literal, is the return address where to jump
       back after the procedure returns.  Branch-and-link
       functionality is enabled for this instruction. */
/* This instruction is non-relocatable: use branches which
   cannot ever generate defects. */
#   undef JITTER_BRANCH_AND_LINK
#   define JITTER_BRANCH_AND_LINK      _JITTER_BRANCH_AND_LINK_FALLBACK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   define JITTER_BRANCH_AND_LINK_WITH _JITTER_BRANCH_AND_LINK_WITH_FALLBACK
#   undef JITTER_BRANCH_FAST_AND_LINK
#   define JITTER_BRANCH_FAST_AND_LINK _JITTER_BRANCH_AND_LINK_FALLBACK

    /* This specialized instruction is returning, and non-relocatable. */
#   define JITTER_RETURN  _JITTER_RETURN_FALLBACK

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 2

    /* The 0th argument is a residual literal. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1


#ifdef JITTER_REPLICATE
/* When jumping to the non-relocatable part it is important not
   to use a fallback version of JITTER_COMPUTED_GOTO, in order to
   prevent GCC from tail-merging. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
    /* Jump to non-relocatable code. */
    JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);

    /* Here the residual arity is given as zero: it's too late to
       skip residuals, since we've already jumped and this code is
       unreachable.  The instruction pointer, if any, is advanced
       in the non-relocatable code. */
    JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-tail-call/nR/retR, _eREPLACEMENT_mtail_mcall__nR__retR, 0)

    /* Relocated code will jump to this label in non-relocated code. */
  JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
    JITTER_COMMENT_IN_ASM_("!REPLACEMENT-tail-call/nR/retR non-relocatable code");
#endif // #ifdef JITTER_REPLICATE
#if defined(JITTER_DISPATCH_NO_THREADING)             \
    && (! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)  \
        || /* is this a replacement? */ 1)
  /* We use the implicit argument at the end of the calling.
     instruction to discover the procedure return address. */
  const void * const _jitter_return_pointer
    __attribute__ ((unused)) = JITTER_ARGP1;
  /* And make it accessible to the user (who will usually call 
     JITTER_BRANCH_AND_LINK) thru a nice macro. */
# define _JITTER_RETURN_ADDRESS _jitter_return_pointer
#endif

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of !REPLACEMENT-tail-call/nR/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  no. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
//#if 0
  //fprintf (stderr, "Executing instruction %s..\n", "!REPLACEMENT-tail-call/nR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing replacement instruction %s..\n", "!REPLACEMENT-tail-call/nR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing non-relocatable instruction %s with JITTER_SPECIALIZED_INSTRUCTION_WORD_NO=%i..\n", "!REPLACEMENT-tail-call/nR/retR", (int) JITTER_SPECIALIZED_INSTRUCTION_WORD_NO); fflush (stderr);
  //fprintf (stderr, "Executing caller replcament: _JITTER_RETURN_ADDRESS is %p..\n", _JITTER_RETURN_ADDRESS); fflush (stderr);
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#undef JITTER_THIS_IS_A_REPLACEMENT
#define JITTER_THIS_IS_A_REPLACEMENT 1

    /* User code for !REPLACEMENT-tail-call/nR/retR . */
  {
/* User-specified code, user code block part: beginning. */

    const jitter_uint in_arity = JITTER_ARGN0;
    jitterlisp_object callee = JITTER_AT_DEPTH_MAINSTACK(in_arity);
    struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(callee);

    if (c->kind == jitterlisp_closure_type_compiled)
      {
        /* Extract the current return address from the return stack, to be
           reused.  Differently from non-tail calls, don't push anything on
           the return stack: the callee will overwrite the top with its
           current value, which is what we want. */
        jitterlispvm_program_point current_link
          = (jitterlispvm_program_point) JITTER_TOP_RETURNSTACK();

        /* Branch-and-relink to the native code, whose first instruction
           will be a prolog. */
        struct jitterlisp_compiled_closure *cc = & c->compiled;
        JITTER_BRANCH_AND_LINK_WITH(cc->first_program_point, current_link);
      }
    else
      {
        /* Unfortunately I cannot really tail-call from compiled code to
           interpreted code.  Instead I will call the interpreter as a C
           function and then return. */
        const struct jitterlisp_interpreted_closure *ic = & c->interpreted;

        /* Push an element on the main stack.  This way we can ensure that
           every actual is accessible thru memory in a contiguous array,
           even if the main stack is TOS-optimized.  Compute the address
           (on the main stack backing) where the actuals begin.

           Notice that the interpreted function we are calling is allowed
           to call into compiled code in its turn.  This is not a problem,
           as we are not moving stack pointers down until the call ends:
           the unused part of the main and return stacks is available to
           the callee. */
        JITTER_PUSH_UNSPECIFIED_MAINSTACK();
        jitterlisp_object *actuals
          // FIXME: add a stack operator to compute this address.
          = (& JITTER_UNDER_TOP_MAINSTACK()) - in_arity + 1;

        /* Call the interpreter. */
        jitterlisp_object interpretation_result
          = jitterlisp_call_interpreted (ic, actuals, in_arity);

        /* Remove as many elements as the in-arity plus one (the callee) from
           the stack, without affecting the top.  Unless JITTER_ARGN0 is
           residual this whole loops compiles to one instruction when the main
           stack is TOS-optimized, and doesn't touch memory. */
        int i;
        for (i = 0; i < in_arity + 1; i ++)
          JITTER_NIP_MAINSTACK();

        /* Now the stack is one element higher than it was before the call,
           containing the unspecified element at the top.  Replace it with
           the result.  Again this doesn't touch memory. */
        JITTER_TOP_MAINSTACK() = interpretation_result;

        /* Return to our original caller. */
        jitter_uint return_address = JITTER_TOP_RETURNSTACK();
        JITTER_DROP_RETURNSTACK();
        JITTER_RETURN(return_address);
      }
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for !REPLACEMENT-tail-call/nR/retR . */

  //fprintf (stderr, "..Executed replacement instruction %s\n", "!REPLACEMENT-tail-call/nR/retR");
  //fprintf (stderr, "..Executed instruction %s\n", "!REPLACEMENT-tail-call/nR/retR");
//#endif // #if 0
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
#ifdef JITTER_REPLICATE
  {
    /* Advance the instruction pointer, if any, to skip every
       residual but the last; branch back to replicated
       code. */
    const void *_jitter_back_to_replicated_code_pointer =
      JITTER_ARGP1;
    JITTER_SKIP_RESIDUALS_;
    goto * _jitter_back_to_replicated_code_pointer;
  }
#endif // #ifdef JITTER_REPLICATE

    /* Undefine the !REPLACEMENT-tail-call/nR/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#if    defined(JITTER_DISPATCH_NO_THREADING)         \
    && ! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)
# undef _JITTER_RETURN_ADDRESS
#endif

#ifndef JITTER_REPLICATE
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-tail-call/nR/retR, _eREPLACEMENT_mtail_mcall__nR__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#endif // #ifndef JITTER_REPLICATE
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for !REPLACEMENT-tail-call/nR/retR, which started with its
       definitions. */
  }
#endif // #if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
/*  End of !REPLACEMENT-tail-call/nR/retR , a replacement specialised instruction */

  /* Ordinary specialised instruction !REPLACEMENT-tail-call-compiled/n0/retR (replacement) */
  /* Omit this specialised instruction altogether unless
     replacements are in fact supported in this
     configuration. */
#if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
  JITTER_INSTRUCTION_PROLOG_(!REPLACEMENT-tail-call-compiled/n0/retR, _eREPLACEMENT_mtail_mcall_mcompiled__n0__retR, cold)
  { /* This block begins with definitions for !REPLACEMENT-tail-call-compiled/n0/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       347
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         !REPLACEMENT-tail-call-compiled/n0/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "tail-call-compiled"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "!REPLACEMENT-tail-call-compiled/n0/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _eREPLACEMENT_mtail_mcall_mcompiled__n0__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement and a caller.
       Its 1-th argument, a literal, is the return address where to jump
       back after the procedure returns.  Branch-and-link
       functionality is enabled for this instruction. */
/* This instruction is non-relocatable: use branches which
   cannot ever generate defects. */
#   undef JITTER_BRANCH_AND_LINK
#   define JITTER_BRANCH_AND_LINK      _JITTER_BRANCH_AND_LINK_FALLBACK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   define JITTER_BRANCH_AND_LINK_WITH _JITTER_BRANCH_AND_LINK_WITH_FALLBACK
#   undef JITTER_BRANCH_FAST_AND_LINK
#   define JITTER_BRANCH_FAST_AND_LINK _JITTER_BRANCH_AND_LINK_FALLBACK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1

    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 0L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1


#ifdef JITTER_REPLICATE
/* When jumping to the non-relocatable part it is important not
   to use a fallback version of JITTER_COMPUTED_GOTO, in order to
   prevent GCC from tail-merging. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
    /* Jump to non-relocatable code. */
    JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);

    /* Here the residual arity is given as zero: it's too late to
       skip residuals, since we've already jumped and this code is
       unreachable.  The instruction pointer, if any, is advanced
       in the non-relocatable code. */
    JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-tail-call-compiled/n0/retR, _eREPLACEMENT_mtail_mcall_mcompiled__n0__retR, 0)

    /* Relocated code will jump to this label in non-relocated code. */
  JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
    JITTER_COMMENT_IN_ASM_("!REPLACEMENT-tail-call-compiled/n0/retR non-relocatable code");
#endif // #ifdef JITTER_REPLICATE
#if defined(JITTER_DISPATCH_NO_THREADING)             \
    && (! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)  \
        || /* is this a replacement? */ 1)
  /* We use the implicit argument at the end of the calling.
     instruction to discover the procedure return address. */
  const void * const _jitter_return_pointer
    __attribute__ ((unused)) = JITTER_ARGP1;
  /* And make it accessible to the user (who will usually call 
     JITTER_BRANCH_AND_LINK) thru a nice macro. */
# define _JITTER_RETURN_ADDRESS _jitter_return_pointer
#endif

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of !REPLACEMENT-tail-call-compiled/n0/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  no. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
//#if 0
  //fprintf (stderr, "Executing instruction %s..\n", "!REPLACEMENT-tail-call-compiled/n0/retR"); fflush (stderr);
  //fprintf (stderr, "Executing replacement instruction %s..\n", "!REPLACEMENT-tail-call-compiled/n0/retR"); fflush (stderr);
  //fprintf (stderr, "Executing non-relocatable instruction %s with JITTER_SPECIALIZED_INSTRUCTION_WORD_NO=%i..\n", "!REPLACEMENT-tail-call-compiled/n0/retR", (int) JITTER_SPECIALIZED_INSTRUCTION_WORD_NO); fflush (stderr);
  //fprintf (stderr, "Executing caller replcament: _JITTER_RETURN_ADDRESS is %p..\n", _JITTER_RETURN_ADDRESS); fflush (stderr);
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#undef JITTER_THIS_IS_A_REPLACEMENT
#define JITTER_THIS_IS_A_REPLACEMENT 1

    /* User code for !REPLACEMENT-tail-call-compiled/n0/retR . */
  {
/* User-specified code, user code block part: beginning. */

    const jitter_uint in_arity = JITTER_ARGN0;
    jitterlisp_object callee = JITTER_AT_DEPTH_MAINSTACK(in_arity);
    struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(callee);

    /* Here we can assume that * c is a compiled closure without checking. */
    struct jitterlisp_compiled_closure *cc = & c->compiled;

    /* Take the current return address from the return stack: I want to keep
       returning there.  Differently from the case of non-tail calls I don't
       push anything on the return stack: the callee prolog will overwrite
       the current top with a copy of itself, which is fine. */
    jitterlispvm_program_point current_link
      = (jitterlispvm_program_point) JITTER_TOP_RETURNSTACK();

    /* Branch-and-relink to the native code, whose first instruction
       will be a prolog. */
    JITTER_BRANCH_AND_LINK_WITH(cc->first_program_point, current_link);
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for !REPLACEMENT-tail-call-compiled/n0/retR . */

  //fprintf (stderr, "..Executed replacement instruction %s\n", "!REPLACEMENT-tail-call-compiled/n0/retR");
  //fprintf (stderr, "..Executed instruction %s\n", "!REPLACEMENT-tail-call-compiled/n0/retR");
//#endif // #if 0
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
#ifdef JITTER_REPLICATE
  {
    /* Advance the instruction pointer, if any, to skip every
       residual but the last; branch back to replicated
       code. */
    const void *_jitter_back_to_replicated_code_pointer =
      JITTER_ARGP1;
    JITTER_SKIP_RESIDUALS_;
    goto * _jitter_back_to_replicated_code_pointer;
  }
#endif // #ifdef JITTER_REPLICATE

    /* Undefine the !REPLACEMENT-tail-call-compiled/n0/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#if    defined(JITTER_DISPATCH_NO_THREADING)         \
    && ! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)
# undef _JITTER_RETURN_ADDRESS
#endif

#ifndef JITTER_REPLICATE
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-tail-call-compiled/n0/retR, _eREPLACEMENT_mtail_mcall_mcompiled__n0__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#endif // #ifndef JITTER_REPLICATE
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for !REPLACEMENT-tail-call-compiled/n0/retR, which started with its
       definitions. */
  }
#endif // #if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
/*  End of !REPLACEMENT-tail-call-compiled/n0/retR , a replacement specialised instruction */

  /* Ordinary specialised instruction !REPLACEMENT-tail-call-compiled/n1/retR (replacement) */
  /* Omit this specialised instruction altogether unless
     replacements are in fact supported in this
     configuration. */
#if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
  JITTER_INSTRUCTION_PROLOG_(!REPLACEMENT-tail-call-compiled/n1/retR, _eREPLACEMENT_mtail_mcall_mcompiled__n1__retR, cold)
  { /* This block begins with definitions for !REPLACEMENT-tail-call-compiled/n1/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       348
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         !REPLACEMENT-tail-call-compiled/n1/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "tail-call-compiled"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "!REPLACEMENT-tail-call-compiled/n1/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _eREPLACEMENT_mtail_mcall_mcompiled__n1__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement and a caller.
       Its 1-th argument, a literal, is the return address where to jump
       back after the procedure returns.  Branch-and-link
       functionality is enabled for this instruction. */
/* This instruction is non-relocatable: use branches which
   cannot ever generate defects. */
#   undef JITTER_BRANCH_AND_LINK
#   define JITTER_BRANCH_AND_LINK      _JITTER_BRANCH_AND_LINK_FALLBACK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   define JITTER_BRANCH_AND_LINK_WITH _JITTER_BRANCH_AND_LINK_WITH_FALLBACK
#   undef JITTER_BRANCH_FAST_AND_LINK
#   define JITTER_BRANCH_FAST_AND_LINK _JITTER_BRANCH_AND_LINK_FALLBACK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1

    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 1L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1


#ifdef JITTER_REPLICATE
/* When jumping to the non-relocatable part it is important not
   to use a fallback version of JITTER_COMPUTED_GOTO, in order to
   prevent GCC from tail-merging. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
    /* Jump to non-relocatable code. */
    JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);

    /* Here the residual arity is given as zero: it's too late to
       skip residuals, since we've already jumped and this code is
       unreachable.  The instruction pointer, if any, is advanced
       in the non-relocatable code. */
    JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-tail-call-compiled/n1/retR, _eREPLACEMENT_mtail_mcall_mcompiled__n1__retR, 0)

    /* Relocated code will jump to this label in non-relocated code. */
  JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
    JITTER_COMMENT_IN_ASM_("!REPLACEMENT-tail-call-compiled/n1/retR non-relocatable code");
#endif // #ifdef JITTER_REPLICATE
#if defined(JITTER_DISPATCH_NO_THREADING)             \
    && (! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)  \
        || /* is this a replacement? */ 1)
  /* We use the implicit argument at the end of the calling.
     instruction to discover the procedure return address. */
  const void * const _jitter_return_pointer
    __attribute__ ((unused)) = JITTER_ARGP1;
  /* And make it accessible to the user (who will usually call 
     JITTER_BRANCH_AND_LINK) thru a nice macro. */
# define _JITTER_RETURN_ADDRESS _jitter_return_pointer
#endif

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of !REPLACEMENT-tail-call-compiled/n1/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  no. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
//#if 0
  //fprintf (stderr, "Executing instruction %s..\n", "!REPLACEMENT-tail-call-compiled/n1/retR"); fflush (stderr);
  //fprintf (stderr, "Executing replacement instruction %s..\n", "!REPLACEMENT-tail-call-compiled/n1/retR"); fflush (stderr);
  //fprintf (stderr, "Executing non-relocatable instruction %s with JITTER_SPECIALIZED_INSTRUCTION_WORD_NO=%i..\n", "!REPLACEMENT-tail-call-compiled/n1/retR", (int) JITTER_SPECIALIZED_INSTRUCTION_WORD_NO); fflush (stderr);
  //fprintf (stderr, "Executing caller replcament: _JITTER_RETURN_ADDRESS is %p..\n", _JITTER_RETURN_ADDRESS); fflush (stderr);
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#undef JITTER_THIS_IS_A_REPLACEMENT
#define JITTER_THIS_IS_A_REPLACEMENT 1

    /* User code for !REPLACEMENT-tail-call-compiled/n1/retR . */
  {
/* User-specified code, user code block part: beginning. */

    const jitter_uint in_arity = JITTER_ARGN0;
    jitterlisp_object callee = JITTER_AT_DEPTH_MAINSTACK(in_arity);
    struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(callee);

    /* Here we can assume that * c is a compiled closure without checking. */
    struct jitterlisp_compiled_closure *cc = & c->compiled;

    /* Take the current return address from the return stack: I want to keep
       returning there.  Differently from the case of non-tail calls I don't
       push anything on the return stack: the callee prolog will overwrite
       the current top with a copy of itself, which is fine. */
    jitterlispvm_program_point current_link
      = (jitterlispvm_program_point) JITTER_TOP_RETURNSTACK();

    /* Branch-and-relink to the native code, whose first instruction
       will be a prolog. */
    JITTER_BRANCH_AND_LINK_WITH(cc->first_program_point, current_link);
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for !REPLACEMENT-tail-call-compiled/n1/retR . */

  //fprintf (stderr, "..Executed replacement instruction %s\n", "!REPLACEMENT-tail-call-compiled/n1/retR");
  //fprintf (stderr, "..Executed instruction %s\n", "!REPLACEMENT-tail-call-compiled/n1/retR");
//#endif // #if 0
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
#ifdef JITTER_REPLICATE
  {
    /* Advance the instruction pointer, if any, to skip every
       residual but the last; branch back to replicated
       code. */
    const void *_jitter_back_to_replicated_code_pointer =
      JITTER_ARGP1;
    JITTER_SKIP_RESIDUALS_;
    goto * _jitter_back_to_replicated_code_pointer;
  }
#endif // #ifdef JITTER_REPLICATE

    /* Undefine the !REPLACEMENT-tail-call-compiled/n1/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#if    defined(JITTER_DISPATCH_NO_THREADING)         \
    && ! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)
# undef _JITTER_RETURN_ADDRESS
#endif

#ifndef JITTER_REPLICATE
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-tail-call-compiled/n1/retR, _eREPLACEMENT_mtail_mcall_mcompiled__n1__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#endif // #ifndef JITTER_REPLICATE
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for !REPLACEMENT-tail-call-compiled/n1/retR, which started with its
       definitions. */
  }
#endif // #if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
/*  End of !REPLACEMENT-tail-call-compiled/n1/retR , a replacement specialised instruction */

  /* Ordinary specialised instruction !REPLACEMENT-tail-call-compiled/n2/retR (replacement) */
  /* Omit this specialised instruction altogether unless
     replacements are in fact supported in this
     configuration. */
#if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
  JITTER_INSTRUCTION_PROLOG_(!REPLACEMENT-tail-call-compiled/n2/retR, _eREPLACEMENT_mtail_mcall_mcompiled__n2__retR, cold)
  { /* This block begins with definitions for !REPLACEMENT-tail-call-compiled/n2/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       349
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         !REPLACEMENT-tail-call-compiled/n2/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "tail-call-compiled"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "!REPLACEMENT-tail-call-compiled/n2/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _eREPLACEMENT_mtail_mcall_mcompiled__n2__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement and a caller.
       Its 1-th argument, a literal, is the return address where to jump
       back after the procedure returns.  Branch-and-link
       functionality is enabled for this instruction. */
/* This instruction is non-relocatable: use branches which
   cannot ever generate defects. */
#   undef JITTER_BRANCH_AND_LINK
#   define JITTER_BRANCH_AND_LINK      _JITTER_BRANCH_AND_LINK_FALLBACK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   define JITTER_BRANCH_AND_LINK_WITH _JITTER_BRANCH_AND_LINK_WITH_FALLBACK
#   undef JITTER_BRANCH_FAST_AND_LINK
#   define JITTER_BRANCH_FAST_AND_LINK _JITTER_BRANCH_AND_LINK_FALLBACK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1

    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 2L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1


#ifdef JITTER_REPLICATE
/* When jumping to the non-relocatable part it is important not
   to use a fallback version of JITTER_COMPUTED_GOTO, in order to
   prevent GCC from tail-merging. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
    /* Jump to non-relocatable code. */
    JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);

    /* Here the residual arity is given as zero: it's too late to
       skip residuals, since we've already jumped and this code is
       unreachable.  The instruction pointer, if any, is advanced
       in the non-relocatable code. */
    JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-tail-call-compiled/n2/retR, _eREPLACEMENT_mtail_mcall_mcompiled__n2__retR, 0)

    /* Relocated code will jump to this label in non-relocated code. */
  JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
    JITTER_COMMENT_IN_ASM_("!REPLACEMENT-tail-call-compiled/n2/retR non-relocatable code");
#endif // #ifdef JITTER_REPLICATE
#if defined(JITTER_DISPATCH_NO_THREADING)             \
    && (! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)  \
        || /* is this a replacement? */ 1)
  /* We use the implicit argument at the end of the calling.
     instruction to discover the procedure return address. */
  const void * const _jitter_return_pointer
    __attribute__ ((unused)) = JITTER_ARGP1;
  /* And make it accessible to the user (who will usually call 
     JITTER_BRANCH_AND_LINK) thru a nice macro. */
# define _JITTER_RETURN_ADDRESS _jitter_return_pointer
#endif

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of !REPLACEMENT-tail-call-compiled/n2/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  no. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
//#if 0
  //fprintf (stderr, "Executing instruction %s..\n", "!REPLACEMENT-tail-call-compiled/n2/retR"); fflush (stderr);
  //fprintf (stderr, "Executing replacement instruction %s..\n", "!REPLACEMENT-tail-call-compiled/n2/retR"); fflush (stderr);
  //fprintf (stderr, "Executing non-relocatable instruction %s with JITTER_SPECIALIZED_INSTRUCTION_WORD_NO=%i..\n", "!REPLACEMENT-tail-call-compiled/n2/retR", (int) JITTER_SPECIALIZED_INSTRUCTION_WORD_NO); fflush (stderr);
  //fprintf (stderr, "Executing caller replcament: _JITTER_RETURN_ADDRESS is %p..\n", _JITTER_RETURN_ADDRESS); fflush (stderr);
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#undef JITTER_THIS_IS_A_REPLACEMENT
#define JITTER_THIS_IS_A_REPLACEMENT 1

    /* User code for !REPLACEMENT-tail-call-compiled/n2/retR . */
  {
/* User-specified code, user code block part: beginning. */

    const jitter_uint in_arity = JITTER_ARGN0;
    jitterlisp_object callee = JITTER_AT_DEPTH_MAINSTACK(in_arity);
    struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(callee);

    /* Here we can assume that * c is a compiled closure without checking. */
    struct jitterlisp_compiled_closure *cc = & c->compiled;

    /* Take the current return address from the return stack: I want to keep
       returning there.  Differently from the case of non-tail calls I don't
       push anything on the return stack: the callee prolog will overwrite
       the current top with a copy of itself, which is fine. */
    jitterlispvm_program_point current_link
      = (jitterlispvm_program_point) JITTER_TOP_RETURNSTACK();

    /* Branch-and-relink to the native code, whose first instruction
       will be a prolog. */
    JITTER_BRANCH_AND_LINK_WITH(cc->first_program_point, current_link);
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for !REPLACEMENT-tail-call-compiled/n2/retR . */

  //fprintf (stderr, "..Executed replacement instruction %s\n", "!REPLACEMENT-tail-call-compiled/n2/retR");
  //fprintf (stderr, "..Executed instruction %s\n", "!REPLACEMENT-tail-call-compiled/n2/retR");
//#endif // #if 0
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
#ifdef JITTER_REPLICATE
  {
    /* Advance the instruction pointer, if any, to skip every
       residual but the last; branch back to replicated
       code. */
    const void *_jitter_back_to_replicated_code_pointer =
      JITTER_ARGP1;
    JITTER_SKIP_RESIDUALS_;
    goto * _jitter_back_to_replicated_code_pointer;
  }
#endif // #ifdef JITTER_REPLICATE

    /* Undefine the !REPLACEMENT-tail-call-compiled/n2/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#if    defined(JITTER_DISPATCH_NO_THREADING)         \
    && ! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)
# undef _JITTER_RETURN_ADDRESS
#endif

#ifndef JITTER_REPLICATE
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-tail-call-compiled/n2/retR, _eREPLACEMENT_mtail_mcall_mcompiled__n2__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#endif // #ifndef JITTER_REPLICATE
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for !REPLACEMENT-tail-call-compiled/n2/retR, which started with its
       definitions. */
  }
#endif // #if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
/*  End of !REPLACEMENT-tail-call-compiled/n2/retR , a replacement specialised instruction */

  /* Ordinary specialised instruction !REPLACEMENT-tail-call-compiled/n3/retR (replacement) */
  /* Omit this specialised instruction altogether unless
     replacements are in fact supported in this
     configuration. */
#if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
  JITTER_INSTRUCTION_PROLOG_(!REPLACEMENT-tail-call-compiled/n3/retR, _eREPLACEMENT_mtail_mcall_mcompiled__n3__retR, cold)
  { /* This block begins with definitions for !REPLACEMENT-tail-call-compiled/n3/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       350
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         !REPLACEMENT-tail-call-compiled/n3/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "tail-call-compiled"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "!REPLACEMENT-tail-call-compiled/n3/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _eREPLACEMENT_mtail_mcall_mcompiled__n3__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement and a caller.
       Its 1-th argument, a literal, is the return address where to jump
       back after the procedure returns.  Branch-and-link
       functionality is enabled for this instruction. */
/* This instruction is non-relocatable: use branches which
   cannot ever generate defects. */
#   undef JITTER_BRANCH_AND_LINK
#   define JITTER_BRANCH_AND_LINK      _JITTER_BRANCH_AND_LINK_FALLBACK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   define JITTER_BRANCH_AND_LINK_WITH _JITTER_BRANCH_AND_LINK_WITH_FALLBACK
#   undef JITTER_BRANCH_FAST_AND_LINK
#   define JITTER_BRANCH_FAST_AND_LINK _JITTER_BRANCH_AND_LINK_FALLBACK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1

    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 3L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1


#ifdef JITTER_REPLICATE
/* When jumping to the non-relocatable part it is important not
   to use a fallback version of JITTER_COMPUTED_GOTO, in order to
   prevent GCC from tail-merging. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
    /* Jump to non-relocatable code. */
    JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);

    /* Here the residual arity is given as zero: it's too late to
       skip residuals, since we've already jumped and this code is
       unreachable.  The instruction pointer, if any, is advanced
       in the non-relocatable code. */
    JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-tail-call-compiled/n3/retR, _eREPLACEMENT_mtail_mcall_mcompiled__n3__retR, 0)

    /* Relocated code will jump to this label in non-relocated code. */
  JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
    JITTER_COMMENT_IN_ASM_("!REPLACEMENT-tail-call-compiled/n3/retR non-relocatable code");
#endif // #ifdef JITTER_REPLICATE
#if defined(JITTER_DISPATCH_NO_THREADING)             \
    && (! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)  \
        || /* is this a replacement? */ 1)
  /* We use the implicit argument at the end of the calling.
     instruction to discover the procedure return address. */
  const void * const _jitter_return_pointer
    __attribute__ ((unused)) = JITTER_ARGP1;
  /* And make it accessible to the user (who will usually call 
     JITTER_BRANCH_AND_LINK) thru a nice macro. */
# define _JITTER_RETURN_ADDRESS _jitter_return_pointer
#endif

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of !REPLACEMENT-tail-call-compiled/n3/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  no. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
//#if 0
  //fprintf (stderr, "Executing instruction %s..\n", "!REPLACEMENT-tail-call-compiled/n3/retR"); fflush (stderr);
  //fprintf (stderr, "Executing replacement instruction %s..\n", "!REPLACEMENT-tail-call-compiled/n3/retR"); fflush (stderr);
  //fprintf (stderr, "Executing non-relocatable instruction %s with JITTER_SPECIALIZED_INSTRUCTION_WORD_NO=%i..\n", "!REPLACEMENT-tail-call-compiled/n3/retR", (int) JITTER_SPECIALIZED_INSTRUCTION_WORD_NO); fflush (stderr);
  //fprintf (stderr, "Executing caller replcament: _JITTER_RETURN_ADDRESS is %p..\n", _JITTER_RETURN_ADDRESS); fflush (stderr);
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#undef JITTER_THIS_IS_A_REPLACEMENT
#define JITTER_THIS_IS_A_REPLACEMENT 1

    /* User code for !REPLACEMENT-tail-call-compiled/n3/retR . */
  {
/* User-specified code, user code block part: beginning. */

    const jitter_uint in_arity = JITTER_ARGN0;
    jitterlisp_object callee = JITTER_AT_DEPTH_MAINSTACK(in_arity);
    struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(callee);

    /* Here we can assume that * c is a compiled closure without checking. */
    struct jitterlisp_compiled_closure *cc = & c->compiled;

    /* Take the current return address from the return stack: I want to keep
       returning there.  Differently from the case of non-tail calls I don't
       push anything on the return stack: the callee prolog will overwrite
       the current top with a copy of itself, which is fine. */
    jitterlispvm_program_point current_link
      = (jitterlispvm_program_point) JITTER_TOP_RETURNSTACK();

    /* Branch-and-relink to the native code, whose first instruction
       will be a prolog. */
    JITTER_BRANCH_AND_LINK_WITH(cc->first_program_point, current_link);
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for !REPLACEMENT-tail-call-compiled/n3/retR . */

  //fprintf (stderr, "..Executed replacement instruction %s\n", "!REPLACEMENT-tail-call-compiled/n3/retR");
  //fprintf (stderr, "..Executed instruction %s\n", "!REPLACEMENT-tail-call-compiled/n3/retR");
//#endif // #if 0
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
#ifdef JITTER_REPLICATE
  {
    /* Advance the instruction pointer, if any, to skip every
       residual but the last; branch back to replicated
       code. */
    const void *_jitter_back_to_replicated_code_pointer =
      JITTER_ARGP1;
    JITTER_SKIP_RESIDUALS_;
    goto * _jitter_back_to_replicated_code_pointer;
  }
#endif // #ifdef JITTER_REPLICATE

    /* Undefine the !REPLACEMENT-tail-call-compiled/n3/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#if    defined(JITTER_DISPATCH_NO_THREADING)         \
    && ! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)
# undef _JITTER_RETURN_ADDRESS
#endif

#ifndef JITTER_REPLICATE
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-tail-call-compiled/n3/retR, _eREPLACEMENT_mtail_mcall_mcompiled__n3__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#endif // #ifndef JITTER_REPLICATE
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for !REPLACEMENT-tail-call-compiled/n3/retR, which started with its
       definitions. */
  }
#endif // #if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
/*  End of !REPLACEMENT-tail-call-compiled/n3/retR , a replacement specialised instruction */

  /* Ordinary specialised instruction !REPLACEMENT-tail-call-compiled/n4/retR (replacement) */
  /* Omit this specialised instruction altogether unless
     replacements are in fact supported in this
     configuration. */
#if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
  JITTER_INSTRUCTION_PROLOG_(!REPLACEMENT-tail-call-compiled/n4/retR, _eREPLACEMENT_mtail_mcall_mcompiled__n4__retR, cold)
  { /* This block begins with definitions for !REPLACEMENT-tail-call-compiled/n4/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       351
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         !REPLACEMENT-tail-call-compiled/n4/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "tail-call-compiled"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "!REPLACEMENT-tail-call-compiled/n4/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _eREPLACEMENT_mtail_mcall_mcompiled__n4__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement and a caller.
       Its 1-th argument, a literal, is the return address where to jump
       back after the procedure returns.  Branch-and-link
       functionality is enabled for this instruction. */
/* This instruction is non-relocatable: use branches which
   cannot ever generate defects. */
#   undef JITTER_BRANCH_AND_LINK
#   define JITTER_BRANCH_AND_LINK      _JITTER_BRANCH_AND_LINK_FALLBACK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   define JITTER_BRANCH_AND_LINK_WITH _JITTER_BRANCH_AND_LINK_WITH_FALLBACK
#   undef JITTER_BRANCH_FAST_AND_LINK
#   define JITTER_BRANCH_FAST_AND_LINK _JITTER_BRANCH_AND_LINK_FALLBACK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1

    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 4L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1


#ifdef JITTER_REPLICATE
/* When jumping to the non-relocatable part it is important not
   to use a fallback version of JITTER_COMPUTED_GOTO, in order to
   prevent GCC from tail-merging. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
    /* Jump to non-relocatable code. */
    JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);

    /* Here the residual arity is given as zero: it's too late to
       skip residuals, since we've already jumped and this code is
       unreachable.  The instruction pointer, if any, is advanced
       in the non-relocatable code. */
    JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-tail-call-compiled/n4/retR, _eREPLACEMENT_mtail_mcall_mcompiled__n4__retR, 0)

    /* Relocated code will jump to this label in non-relocated code. */
  JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
    JITTER_COMMENT_IN_ASM_("!REPLACEMENT-tail-call-compiled/n4/retR non-relocatable code");
#endif // #ifdef JITTER_REPLICATE
#if defined(JITTER_DISPATCH_NO_THREADING)             \
    && (! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)  \
        || /* is this a replacement? */ 1)
  /* We use the implicit argument at the end of the calling.
     instruction to discover the procedure return address. */
  const void * const _jitter_return_pointer
    __attribute__ ((unused)) = JITTER_ARGP1;
  /* And make it accessible to the user (who will usually call 
     JITTER_BRANCH_AND_LINK) thru a nice macro. */
# define _JITTER_RETURN_ADDRESS _jitter_return_pointer
#endif

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of !REPLACEMENT-tail-call-compiled/n4/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  no. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
//#if 0
  //fprintf (stderr, "Executing instruction %s..\n", "!REPLACEMENT-tail-call-compiled/n4/retR"); fflush (stderr);
  //fprintf (stderr, "Executing replacement instruction %s..\n", "!REPLACEMENT-tail-call-compiled/n4/retR"); fflush (stderr);
  //fprintf (stderr, "Executing non-relocatable instruction %s with JITTER_SPECIALIZED_INSTRUCTION_WORD_NO=%i..\n", "!REPLACEMENT-tail-call-compiled/n4/retR", (int) JITTER_SPECIALIZED_INSTRUCTION_WORD_NO); fflush (stderr);
  //fprintf (stderr, "Executing caller replcament: _JITTER_RETURN_ADDRESS is %p..\n", _JITTER_RETURN_ADDRESS); fflush (stderr);
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#undef JITTER_THIS_IS_A_REPLACEMENT
#define JITTER_THIS_IS_A_REPLACEMENT 1

    /* User code for !REPLACEMENT-tail-call-compiled/n4/retR . */
  {
/* User-specified code, user code block part: beginning. */

    const jitter_uint in_arity = JITTER_ARGN0;
    jitterlisp_object callee = JITTER_AT_DEPTH_MAINSTACK(in_arity);
    struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(callee);

    /* Here we can assume that * c is a compiled closure without checking. */
    struct jitterlisp_compiled_closure *cc = & c->compiled;

    /* Take the current return address from the return stack: I want to keep
       returning there.  Differently from the case of non-tail calls I don't
       push anything on the return stack: the callee prolog will overwrite
       the current top with a copy of itself, which is fine. */
    jitterlispvm_program_point current_link
      = (jitterlispvm_program_point) JITTER_TOP_RETURNSTACK();

    /* Branch-and-relink to the native code, whose first instruction
       will be a prolog. */
    JITTER_BRANCH_AND_LINK_WITH(cc->first_program_point, current_link);
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for !REPLACEMENT-tail-call-compiled/n4/retR . */

  //fprintf (stderr, "..Executed replacement instruction %s\n", "!REPLACEMENT-tail-call-compiled/n4/retR");
  //fprintf (stderr, "..Executed instruction %s\n", "!REPLACEMENT-tail-call-compiled/n4/retR");
//#endif // #if 0
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
#ifdef JITTER_REPLICATE
  {
    /* Advance the instruction pointer, if any, to skip every
       residual but the last; branch back to replicated
       code. */
    const void *_jitter_back_to_replicated_code_pointer =
      JITTER_ARGP1;
    JITTER_SKIP_RESIDUALS_;
    goto * _jitter_back_to_replicated_code_pointer;
  }
#endif // #ifdef JITTER_REPLICATE

    /* Undefine the !REPLACEMENT-tail-call-compiled/n4/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#if    defined(JITTER_DISPATCH_NO_THREADING)         \
    && ! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)
# undef _JITTER_RETURN_ADDRESS
#endif

#ifndef JITTER_REPLICATE
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-tail-call-compiled/n4/retR, _eREPLACEMENT_mtail_mcall_mcompiled__n4__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#endif // #ifndef JITTER_REPLICATE
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for !REPLACEMENT-tail-call-compiled/n4/retR, which started with its
       definitions. */
  }
#endif // #if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
/*  End of !REPLACEMENT-tail-call-compiled/n4/retR , a replacement specialised instruction */

  /* Ordinary specialised instruction !REPLACEMENT-tail-call-compiled/n5/retR (replacement) */
  /* Omit this specialised instruction altogether unless
     replacements are in fact supported in this
     configuration. */
#if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
  JITTER_INSTRUCTION_PROLOG_(!REPLACEMENT-tail-call-compiled/n5/retR, _eREPLACEMENT_mtail_mcall_mcompiled__n5__retR, cold)
  { /* This block begins with definitions for !REPLACEMENT-tail-call-compiled/n5/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       352
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         !REPLACEMENT-tail-call-compiled/n5/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "tail-call-compiled"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "!REPLACEMENT-tail-call-compiled/n5/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _eREPLACEMENT_mtail_mcall_mcompiled__n5__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement and a caller.
       Its 1-th argument, a literal, is the return address where to jump
       back after the procedure returns.  Branch-and-link
       functionality is enabled for this instruction. */
/* This instruction is non-relocatable: use branches which
   cannot ever generate defects. */
#   undef JITTER_BRANCH_AND_LINK
#   define JITTER_BRANCH_AND_LINK      _JITTER_BRANCH_AND_LINK_FALLBACK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   define JITTER_BRANCH_AND_LINK_WITH _JITTER_BRANCH_AND_LINK_WITH_FALLBACK
#   undef JITTER_BRANCH_FAST_AND_LINK
#   define JITTER_BRANCH_FAST_AND_LINK _JITTER_BRANCH_AND_LINK_FALLBACK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1

    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 5L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1


#ifdef JITTER_REPLICATE
/* When jumping to the non-relocatable part it is important not
   to use a fallback version of JITTER_COMPUTED_GOTO, in order to
   prevent GCC from tail-merging. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
    /* Jump to non-relocatable code. */
    JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);

    /* Here the residual arity is given as zero: it's too late to
       skip residuals, since we've already jumped and this code is
       unreachable.  The instruction pointer, if any, is advanced
       in the non-relocatable code. */
    JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-tail-call-compiled/n5/retR, _eREPLACEMENT_mtail_mcall_mcompiled__n5__retR, 0)

    /* Relocated code will jump to this label in non-relocated code. */
  JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
    JITTER_COMMENT_IN_ASM_("!REPLACEMENT-tail-call-compiled/n5/retR non-relocatable code");
#endif // #ifdef JITTER_REPLICATE
#if defined(JITTER_DISPATCH_NO_THREADING)             \
    && (! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)  \
        || /* is this a replacement? */ 1)
  /* We use the implicit argument at the end of the calling.
     instruction to discover the procedure return address. */
  const void * const _jitter_return_pointer
    __attribute__ ((unused)) = JITTER_ARGP1;
  /* And make it accessible to the user (who will usually call 
     JITTER_BRANCH_AND_LINK) thru a nice macro. */
# define _JITTER_RETURN_ADDRESS _jitter_return_pointer
#endif

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of !REPLACEMENT-tail-call-compiled/n5/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  no. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
//#if 0
  //fprintf (stderr, "Executing instruction %s..\n", "!REPLACEMENT-tail-call-compiled/n5/retR"); fflush (stderr);
  //fprintf (stderr, "Executing replacement instruction %s..\n", "!REPLACEMENT-tail-call-compiled/n5/retR"); fflush (stderr);
  //fprintf (stderr, "Executing non-relocatable instruction %s with JITTER_SPECIALIZED_INSTRUCTION_WORD_NO=%i..\n", "!REPLACEMENT-tail-call-compiled/n5/retR", (int) JITTER_SPECIALIZED_INSTRUCTION_WORD_NO); fflush (stderr);
  //fprintf (stderr, "Executing caller replcament: _JITTER_RETURN_ADDRESS is %p..\n", _JITTER_RETURN_ADDRESS); fflush (stderr);
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#undef JITTER_THIS_IS_A_REPLACEMENT
#define JITTER_THIS_IS_A_REPLACEMENT 1

    /* User code for !REPLACEMENT-tail-call-compiled/n5/retR . */
  {
/* User-specified code, user code block part: beginning. */

    const jitter_uint in_arity = JITTER_ARGN0;
    jitterlisp_object callee = JITTER_AT_DEPTH_MAINSTACK(in_arity);
    struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(callee);

    /* Here we can assume that * c is a compiled closure without checking. */
    struct jitterlisp_compiled_closure *cc = & c->compiled;

    /* Take the current return address from the return stack: I want to keep
       returning there.  Differently from the case of non-tail calls I don't
       push anything on the return stack: the callee prolog will overwrite
       the current top with a copy of itself, which is fine. */
    jitterlispvm_program_point current_link
      = (jitterlispvm_program_point) JITTER_TOP_RETURNSTACK();

    /* Branch-and-relink to the native code, whose first instruction
       will be a prolog. */
    JITTER_BRANCH_AND_LINK_WITH(cc->first_program_point, current_link);
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for !REPLACEMENT-tail-call-compiled/n5/retR . */

  //fprintf (stderr, "..Executed replacement instruction %s\n", "!REPLACEMENT-tail-call-compiled/n5/retR");
  //fprintf (stderr, "..Executed instruction %s\n", "!REPLACEMENT-tail-call-compiled/n5/retR");
//#endif // #if 0
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
#ifdef JITTER_REPLICATE
  {
    /* Advance the instruction pointer, if any, to skip every
       residual but the last; branch back to replicated
       code. */
    const void *_jitter_back_to_replicated_code_pointer =
      JITTER_ARGP1;
    JITTER_SKIP_RESIDUALS_;
    goto * _jitter_back_to_replicated_code_pointer;
  }
#endif // #ifdef JITTER_REPLICATE

    /* Undefine the !REPLACEMENT-tail-call-compiled/n5/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#if    defined(JITTER_DISPATCH_NO_THREADING)         \
    && ! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)
# undef _JITTER_RETURN_ADDRESS
#endif

#ifndef JITTER_REPLICATE
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-tail-call-compiled/n5/retR, _eREPLACEMENT_mtail_mcall_mcompiled__n5__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#endif // #ifndef JITTER_REPLICATE
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for !REPLACEMENT-tail-call-compiled/n5/retR, which started with its
       definitions. */
  }
#endif // #if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
/*  End of !REPLACEMENT-tail-call-compiled/n5/retR , a replacement specialised instruction */

  /* Ordinary specialised instruction !REPLACEMENT-tail-call-compiled/n6/retR (replacement) */
  /* Omit this specialised instruction altogether unless
     replacements are in fact supported in this
     configuration. */
#if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
  JITTER_INSTRUCTION_PROLOG_(!REPLACEMENT-tail-call-compiled/n6/retR, _eREPLACEMENT_mtail_mcall_mcompiled__n6__retR, cold)
  { /* This block begins with definitions for !REPLACEMENT-tail-call-compiled/n6/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       353
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         !REPLACEMENT-tail-call-compiled/n6/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "tail-call-compiled"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "!REPLACEMENT-tail-call-compiled/n6/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _eREPLACEMENT_mtail_mcall_mcompiled__n6__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement and a caller.
       Its 1-th argument, a literal, is the return address where to jump
       back after the procedure returns.  Branch-and-link
       functionality is enabled for this instruction. */
/* This instruction is non-relocatable: use branches which
   cannot ever generate defects. */
#   undef JITTER_BRANCH_AND_LINK
#   define JITTER_BRANCH_AND_LINK      _JITTER_BRANCH_AND_LINK_FALLBACK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   define JITTER_BRANCH_AND_LINK_WITH _JITTER_BRANCH_AND_LINK_WITH_FALLBACK
#   undef JITTER_BRANCH_FAST_AND_LINK
#   define JITTER_BRANCH_FAST_AND_LINK _JITTER_BRANCH_AND_LINK_FALLBACK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1

    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 6L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1


#ifdef JITTER_REPLICATE
/* When jumping to the non-relocatable part it is important not
   to use a fallback version of JITTER_COMPUTED_GOTO, in order to
   prevent GCC from tail-merging. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
    /* Jump to non-relocatable code. */
    JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);

    /* Here the residual arity is given as zero: it's too late to
       skip residuals, since we've already jumped and this code is
       unreachable.  The instruction pointer, if any, is advanced
       in the non-relocatable code. */
    JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-tail-call-compiled/n6/retR, _eREPLACEMENT_mtail_mcall_mcompiled__n6__retR, 0)

    /* Relocated code will jump to this label in non-relocated code. */
  JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
    JITTER_COMMENT_IN_ASM_("!REPLACEMENT-tail-call-compiled/n6/retR non-relocatable code");
#endif // #ifdef JITTER_REPLICATE
#if defined(JITTER_DISPATCH_NO_THREADING)             \
    && (! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)  \
        || /* is this a replacement? */ 1)
  /* We use the implicit argument at the end of the calling.
     instruction to discover the procedure return address. */
  const void * const _jitter_return_pointer
    __attribute__ ((unused)) = JITTER_ARGP1;
  /* And make it accessible to the user (who will usually call 
     JITTER_BRANCH_AND_LINK) thru a nice macro. */
# define _JITTER_RETURN_ADDRESS _jitter_return_pointer
#endif

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of !REPLACEMENT-tail-call-compiled/n6/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  no. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
//#if 0
  //fprintf (stderr, "Executing instruction %s..\n", "!REPLACEMENT-tail-call-compiled/n6/retR"); fflush (stderr);
  //fprintf (stderr, "Executing replacement instruction %s..\n", "!REPLACEMENT-tail-call-compiled/n6/retR"); fflush (stderr);
  //fprintf (stderr, "Executing non-relocatable instruction %s with JITTER_SPECIALIZED_INSTRUCTION_WORD_NO=%i..\n", "!REPLACEMENT-tail-call-compiled/n6/retR", (int) JITTER_SPECIALIZED_INSTRUCTION_WORD_NO); fflush (stderr);
  //fprintf (stderr, "Executing caller replcament: _JITTER_RETURN_ADDRESS is %p..\n", _JITTER_RETURN_ADDRESS); fflush (stderr);
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#undef JITTER_THIS_IS_A_REPLACEMENT
#define JITTER_THIS_IS_A_REPLACEMENT 1

    /* User code for !REPLACEMENT-tail-call-compiled/n6/retR . */
  {
/* User-specified code, user code block part: beginning. */

    const jitter_uint in_arity = JITTER_ARGN0;
    jitterlisp_object callee = JITTER_AT_DEPTH_MAINSTACK(in_arity);
    struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(callee);

    /* Here we can assume that * c is a compiled closure without checking. */
    struct jitterlisp_compiled_closure *cc = & c->compiled;

    /* Take the current return address from the return stack: I want to keep
       returning there.  Differently from the case of non-tail calls I don't
       push anything on the return stack: the callee prolog will overwrite
       the current top with a copy of itself, which is fine. */
    jitterlispvm_program_point current_link
      = (jitterlispvm_program_point) JITTER_TOP_RETURNSTACK();

    /* Branch-and-relink to the native code, whose first instruction
       will be a prolog. */
    JITTER_BRANCH_AND_LINK_WITH(cc->first_program_point, current_link);
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for !REPLACEMENT-tail-call-compiled/n6/retR . */

  //fprintf (stderr, "..Executed replacement instruction %s\n", "!REPLACEMENT-tail-call-compiled/n6/retR");
  //fprintf (stderr, "..Executed instruction %s\n", "!REPLACEMENT-tail-call-compiled/n6/retR");
//#endif // #if 0
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
#ifdef JITTER_REPLICATE
  {
    /* Advance the instruction pointer, if any, to skip every
       residual but the last; branch back to replicated
       code. */
    const void *_jitter_back_to_replicated_code_pointer =
      JITTER_ARGP1;
    JITTER_SKIP_RESIDUALS_;
    goto * _jitter_back_to_replicated_code_pointer;
  }
#endif // #ifdef JITTER_REPLICATE

    /* Undefine the !REPLACEMENT-tail-call-compiled/n6/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#if    defined(JITTER_DISPATCH_NO_THREADING)         \
    && ! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)
# undef _JITTER_RETURN_ADDRESS
#endif

#ifndef JITTER_REPLICATE
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-tail-call-compiled/n6/retR, _eREPLACEMENT_mtail_mcall_mcompiled__n6__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#endif // #ifndef JITTER_REPLICATE
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for !REPLACEMENT-tail-call-compiled/n6/retR, which started with its
       definitions. */
  }
#endif // #if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
/*  End of !REPLACEMENT-tail-call-compiled/n6/retR , a replacement specialised instruction */

  /* Ordinary specialised instruction !REPLACEMENT-tail-call-compiled/n7/retR (replacement) */
  /* Omit this specialised instruction altogether unless
     replacements are in fact supported in this
     configuration. */
#if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
  JITTER_INSTRUCTION_PROLOG_(!REPLACEMENT-tail-call-compiled/n7/retR, _eREPLACEMENT_mtail_mcall_mcompiled__n7__retR, cold)
  { /* This block begins with definitions for !REPLACEMENT-tail-call-compiled/n7/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       354
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         !REPLACEMENT-tail-call-compiled/n7/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "tail-call-compiled"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "!REPLACEMENT-tail-call-compiled/n7/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _eREPLACEMENT_mtail_mcall_mcompiled__n7__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement and a caller.
       Its 1-th argument, a literal, is the return address where to jump
       back after the procedure returns.  Branch-and-link
       functionality is enabled for this instruction. */
/* This instruction is non-relocatable: use branches which
   cannot ever generate defects. */
#   undef JITTER_BRANCH_AND_LINK
#   define JITTER_BRANCH_AND_LINK      _JITTER_BRANCH_AND_LINK_FALLBACK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   define JITTER_BRANCH_AND_LINK_WITH _JITTER_BRANCH_AND_LINK_WITH_FALLBACK
#   undef JITTER_BRANCH_FAST_AND_LINK
#   define JITTER_BRANCH_FAST_AND_LINK _JITTER_BRANCH_AND_LINK_FALLBACK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1

    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 7L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1


#ifdef JITTER_REPLICATE
/* When jumping to the non-relocatable part it is important not
   to use a fallback version of JITTER_COMPUTED_GOTO, in order to
   prevent GCC from tail-merging. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
    /* Jump to non-relocatable code. */
    JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);

    /* Here the residual arity is given as zero: it's too late to
       skip residuals, since we've already jumped and this code is
       unreachable.  The instruction pointer, if any, is advanced
       in the non-relocatable code. */
    JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-tail-call-compiled/n7/retR, _eREPLACEMENT_mtail_mcall_mcompiled__n7__retR, 0)

    /* Relocated code will jump to this label in non-relocated code. */
  JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
    JITTER_COMMENT_IN_ASM_("!REPLACEMENT-tail-call-compiled/n7/retR non-relocatable code");
#endif // #ifdef JITTER_REPLICATE
#if defined(JITTER_DISPATCH_NO_THREADING)             \
    && (! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)  \
        || /* is this a replacement? */ 1)
  /* We use the implicit argument at the end of the calling.
     instruction to discover the procedure return address. */
  const void * const _jitter_return_pointer
    __attribute__ ((unused)) = JITTER_ARGP1;
  /* And make it accessible to the user (who will usually call 
     JITTER_BRANCH_AND_LINK) thru a nice macro. */
# define _JITTER_RETURN_ADDRESS _jitter_return_pointer
#endif

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of !REPLACEMENT-tail-call-compiled/n7/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  no. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
//#if 0
  //fprintf (stderr, "Executing instruction %s..\n", "!REPLACEMENT-tail-call-compiled/n7/retR"); fflush (stderr);
  //fprintf (stderr, "Executing replacement instruction %s..\n", "!REPLACEMENT-tail-call-compiled/n7/retR"); fflush (stderr);
  //fprintf (stderr, "Executing non-relocatable instruction %s with JITTER_SPECIALIZED_INSTRUCTION_WORD_NO=%i..\n", "!REPLACEMENT-tail-call-compiled/n7/retR", (int) JITTER_SPECIALIZED_INSTRUCTION_WORD_NO); fflush (stderr);
  //fprintf (stderr, "Executing caller replcament: _JITTER_RETURN_ADDRESS is %p..\n", _JITTER_RETURN_ADDRESS); fflush (stderr);
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#undef JITTER_THIS_IS_A_REPLACEMENT
#define JITTER_THIS_IS_A_REPLACEMENT 1

    /* User code for !REPLACEMENT-tail-call-compiled/n7/retR . */
  {
/* User-specified code, user code block part: beginning. */

    const jitter_uint in_arity = JITTER_ARGN0;
    jitterlisp_object callee = JITTER_AT_DEPTH_MAINSTACK(in_arity);
    struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(callee);

    /* Here we can assume that * c is a compiled closure without checking. */
    struct jitterlisp_compiled_closure *cc = & c->compiled;

    /* Take the current return address from the return stack: I want to keep
       returning there.  Differently from the case of non-tail calls I don't
       push anything on the return stack: the callee prolog will overwrite
       the current top with a copy of itself, which is fine. */
    jitterlispvm_program_point current_link
      = (jitterlispvm_program_point) JITTER_TOP_RETURNSTACK();

    /* Branch-and-relink to the native code, whose first instruction
       will be a prolog. */
    JITTER_BRANCH_AND_LINK_WITH(cc->first_program_point, current_link);
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for !REPLACEMENT-tail-call-compiled/n7/retR . */

  //fprintf (stderr, "..Executed replacement instruction %s\n", "!REPLACEMENT-tail-call-compiled/n7/retR");
  //fprintf (stderr, "..Executed instruction %s\n", "!REPLACEMENT-tail-call-compiled/n7/retR");
//#endif // #if 0
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
#ifdef JITTER_REPLICATE
  {
    /* Advance the instruction pointer, if any, to skip every
       residual but the last; branch back to replicated
       code. */
    const void *_jitter_back_to_replicated_code_pointer =
      JITTER_ARGP1;
    JITTER_SKIP_RESIDUALS_;
    goto * _jitter_back_to_replicated_code_pointer;
  }
#endif // #ifdef JITTER_REPLICATE

    /* Undefine the !REPLACEMENT-tail-call-compiled/n7/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#if    defined(JITTER_DISPATCH_NO_THREADING)         \
    && ! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)
# undef _JITTER_RETURN_ADDRESS
#endif

#ifndef JITTER_REPLICATE
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-tail-call-compiled/n7/retR, _eREPLACEMENT_mtail_mcall_mcompiled__n7__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#endif // #ifndef JITTER_REPLICATE
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for !REPLACEMENT-tail-call-compiled/n7/retR, which started with its
       definitions. */
  }
#endif // #if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
/*  End of !REPLACEMENT-tail-call-compiled/n7/retR , a replacement specialised instruction */

  /* Ordinary specialised instruction !REPLACEMENT-tail-call-compiled/n8/retR (replacement) */
  /* Omit this specialised instruction altogether unless
     replacements are in fact supported in this
     configuration. */
#if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
  JITTER_INSTRUCTION_PROLOG_(!REPLACEMENT-tail-call-compiled/n8/retR, _eREPLACEMENT_mtail_mcall_mcompiled__n8__retR, cold)
  { /* This block begins with definitions for !REPLACEMENT-tail-call-compiled/n8/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       355
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         !REPLACEMENT-tail-call-compiled/n8/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "tail-call-compiled"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "!REPLACEMENT-tail-call-compiled/n8/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _eREPLACEMENT_mtail_mcall_mcompiled__n8__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement and a caller.
       Its 1-th argument, a literal, is the return address where to jump
       back after the procedure returns.  Branch-and-link
       functionality is enabled for this instruction. */
/* This instruction is non-relocatable: use branches which
   cannot ever generate defects. */
#   undef JITTER_BRANCH_AND_LINK
#   define JITTER_BRANCH_AND_LINK      _JITTER_BRANCH_AND_LINK_FALLBACK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   define JITTER_BRANCH_AND_LINK_WITH _JITTER_BRANCH_AND_LINK_WITH_FALLBACK
#   undef JITTER_BRANCH_FAST_AND_LINK
#   define JITTER_BRANCH_FAST_AND_LINK _JITTER_BRANCH_AND_LINK_FALLBACK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1

    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 8L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1


#ifdef JITTER_REPLICATE
/* When jumping to the non-relocatable part it is important not
   to use a fallback version of JITTER_COMPUTED_GOTO, in order to
   prevent GCC from tail-merging. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
    /* Jump to non-relocatable code. */
    JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);

    /* Here the residual arity is given as zero: it's too late to
       skip residuals, since we've already jumped and this code is
       unreachable.  The instruction pointer, if any, is advanced
       in the non-relocatable code. */
    JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-tail-call-compiled/n8/retR, _eREPLACEMENT_mtail_mcall_mcompiled__n8__retR, 0)

    /* Relocated code will jump to this label in non-relocated code. */
  JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
    JITTER_COMMENT_IN_ASM_("!REPLACEMENT-tail-call-compiled/n8/retR non-relocatable code");
#endif // #ifdef JITTER_REPLICATE
#if defined(JITTER_DISPATCH_NO_THREADING)             \
    && (! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)  \
        || /* is this a replacement? */ 1)
  /* We use the implicit argument at the end of the calling.
     instruction to discover the procedure return address. */
  const void * const _jitter_return_pointer
    __attribute__ ((unused)) = JITTER_ARGP1;
  /* And make it accessible to the user (who will usually call 
     JITTER_BRANCH_AND_LINK) thru a nice macro. */
# define _JITTER_RETURN_ADDRESS _jitter_return_pointer
#endif

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of !REPLACEMENT-tail-call-compiled/n8/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  no. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
//#if 0
  //fprintf (stderr, "Executing instruction %s..\n", "!REPLACEMENT-tail-call-compiled/n8/retR"); fflush (stderr);
  //fprintf (stderr, "Executing replacement instruction %s..\n", "!REPLACEMENT-tail-call-compiled/n8/retR"); fflush (stderr);
  //fprintf (stderr, "Executing non-relocatable instruction %s with JITTER_SPECIALIZED_INSTRUCTION_WORD_NO=%i..\n", "!REPLACEMENT-tail-call-compiled/n8/retR", (int) JITTER_SPECIALIZED_INSTRUCTION_WORD_NO); fflush (stderr);
  //fprintf (stderr, "Executing caller replcament: _JITTER_RETURN_ADDRESS is %p..\n", _JITTER_RETURN_ADDRESS); fflush (stderr);
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#undef JITTER_THIS_IS_A_REPLACEMENT
#define JITTER_THIS_IS_A_REPLACEMENT 1

    /* User code for !REPLACEMENT-tail-call-compiled/n8/retR . */
  {
/* User-specified code, user code block part: beginning. */

    const jitter_uint in_arity = JITTER_ARGN0;
    jitterlisp_object callee = JITTER_AT_DEPTH_MAINSTACK(in_arity);
    struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(callee);

    /* Here we can assume that * c is a compiled closure without checking. */
    struct jitterlisp_compiled_closure *cc = & c->compiled;

    /* Take the current return address from the return stack: I want to keep
       returning there.  Differently from the case of non-tail calls I don't
       push anything on the return stack: the callee prolog will overwrite
       the current top with a copy of itself, which is fine. */
    jitterlispvm_program_point current_link
      = (jitterlispvm_program_point) JITTER_TOP_RETURNSTACK();

    /* Branch-and-relink to the native code, whose first instruction
       will be a prolog. */
    JITTER_BRANCH_AND_LINK_WITH(cc->first_program_point, current_link);
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for !REPLACEMENT-tail-call-compiled/n8/retR . */

  //fprintf (stderr, "..Executed replacement instruction %s\n", "!REPLACEMENT-tail-call-compiled/n8/retR");
  //fprintf (stderr, "..Executed instruction %s\n", "!REPLACEMENT-tail-call-compiled/n8/retR");
//#endif // #if 0
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
#ifdef JITTER_REPLICATE
  {
    /* Advance the instruction pointer, if any, to skip every
       residual but the last; branch back to replicated
       code. */
    const void *_jitter_back_to_replicated_code_pointer =
      JITTER_ARGP1;
    JITTER_SKIP_RESIDUALS_;
    goto * _jitter_back_to_replicated_code_pointer;
  }
#endif // #ifdef JITTER_REPLICATE

    /* Undefine the !REPLACEMENT-tail-call-compiled/n8/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#if    defined(JITTER_DISPATCH_NO_THREADING)         \
    && ! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)
# undef _JITTER_RETURN_ADDRESS
#endif

#ifndef JITTER_REPLICATE
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-tail-call-compiled/n8/retR, _eREPLACEMENT_mtail_mcall_mcompiled__n8__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#endif // #ifndef JITTER_REPLICATE
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for !REPLACEMENT-tail-call-compiled/n8/retR, which started with its
       definitions. */
  }
#endif // #if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
/*  End of !REPLACEMENT-tail-call-compiled/n8/retR , a replacement specialised instruction */

  /* Ordinary specialised instruction !REPLACEMENT-tail-call-compiled/n9/retR (replacement) */
  /* Omit this specialised instruction altogether unless
     replacements are in fact supported in this
     configuration. */
#if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
  JITTER_INSTRUCTION_PROLOG_(!REPLACEMENT-tail-call-compiled/n9/retR, _eREPLACEMENT_mtail_mcall_mcompiled__n9__retR, cold)
  { /* This block begins with definitions for !REPLACEMENT-tail-call-compiled/n9/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       356
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         !REPLACEMENT-tail-call-compiled/n9/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "tail-call-compiled"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "!REPLACEMENT-tail-call-compiled/n9/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _eREPLACEMENT_mtail_mcall_mcompiled__n9__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement and a caller.
       Its 1-th argument, a literal, is the return address where to jump
       back after the procedure returns.  Branch-and-link
       functionality is enabled for this instruction. */
/* This instruction is non-relocatable: use branches which
   cannot ever generate defects. */
#   undef JITTER_BRANCH_AND_LINK
#   define JITTER_BRANCH_AND_LINK      _JITTER_BRANCH_AND_LINK_FALLBACK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   define JITTER_BRANCH_AND_LINK_WITH _JITTER_BRANCH_AND_LINK_WITH_FALLBACK
#   undef JITTER_BRANCH_FAST_AND_LINK
#   define JITTER_BRANCH_FAST_AND_LINK _JITTER_BRANCH_AND_LINK_FALLBACK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1

    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 9L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1


#ifdef JITTER_REPLICATE
/* When jumping to the non-relocatable part it is important not
   to use a fallback version of JITTER_COMPUTED_GOTO, in order to
   prevent GCC from tail-merging. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
    /* Jump to non-relocatable code. */
    JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);

    /* Here the residual arity is given as zero: it's too late to
       skip residuals, since we've already jumped and this code is
       unreachable.  The instruction pointer, if any, is advanced
       in the non-relocatable code. */
    JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-tail-call-compiled/n9/retR, _eREPLACEMENT_mtail_mcall_mcompiled__n9__retR, 0)

    /* Relocated code will jump to this label in non-relocated code. */
  JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
    JITTER_COMMENT_IN_ASM_("!REPLACEMENT-tail-call-compiled/n9/retR non-relocatable code");
#endif // #ifdef JITTER_REPLICATE
#if defined(JITTER_DISPATCH_NO_THREADING)             \
    && (! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)  \
        || /* is this a replacement? */ 1)
  /* We use the implicit argument at the end of the calling.
     instruction to discover the procedure return address. */
  const void * const _jitter_return_pointer
    __attribute__ ((unused)) = JITTER_ARGP1;
  /* And make it accessible to the user (who will usually call 
     JITTER_BRANCH_AND_LINK) thru a nice macro. */
# define _JITTER_RETURN_ADDRESS _jitter_return_pointer
#endif

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of !REPLACEMENT-tail-call-compiled/n9/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  no. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
//#if 0
  //fprintf (stderr, "Executing instruction %s..\n", "!REPLACEMENT-tail-call-compiled/n9/retR"); fflush (stderr);
  //fprintf (stderr, "Executing replacement instruction %s..\n", "!REPLACEMENT-tail-call-compiled/n9/retR"); fflush (stderr);
  //fprintf (stderr, "Executing non-relocatable instruction %s with JITTER_SPECIALIZED_INSTRUCTION_WORD_NO=%i..\n", "!REPLACEMENT-tail-call-compiled/n9/retR", (int) JITTER_SPECIALIZED_INSTRUCTION_WORD_NO); fflush (stderr);
  //fprintf (stderr, "Executing caller replcament: _JITTER_RETURN_ADDRESS is %p..\n", _JITTER_RETURN_ADDRESS); fflush (stderr);
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#undef JITTER_THIS_IS_A_REPLACEMENT
#define JITTER_THIS_IS_A_REPLACEMENT 1

    /* User code for !REPLACEMENT-tail-call-compiled/n9/retR . */
  {
/* User-specified code, user code block part: beginning. */

    const jitter_uint in_arity = JITTER_ARGN0;
    jitterlisp_object callee = JITTER_AT_DEPTH_MAINSTACK(in_arity);
    struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(callee);

    /* Here we can assume that * c is a compiled closure without checking. */
    struct jitterlisp_compiled_closure *cc = & c->compiled;

    /* Take the current return address from the return stack: I want to keep
       returning there.  Differently from the case of non-tail calls I don't
       push anything on the return stack: the callee prolog will overwrite
       the current top with a copy of itself, which is fine. */
    jitterlispvm_program_point current_link
      = (jitterlispvm_program_point) JITTER_TOP_RETURNSTACK();

    /* Branch-and-relink to the native code, whose first instruction
       will be a prolog. */
    JITTER_BRANCH_AND_LINK_WITH(cc->first_program_point, current_link);
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for !REPLACEMENT-tail-call-compiled/n9/retR . */

  //fprintf (stderr, "..Executed replacement instruction %s\n", "!REPLACEMENT-tail-call-compiled/n9/retR");
  //fprintf (stderr, "..Executed instruction %s\n", "!REPLACEMENT-tail-call-compiled/n9/retR");
//#endif // #if 0
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
#ifdef JITTER_REPLICATE
  {
    /* Advance the instruction pointer, if any, to skip every
       residual but the last; branch back to replicated
       code. */
    const void *_jitter_back_to_replicated_code_pointer =
      JITTER_ARGP1;
    JITTER_SKIP_RESIDUALS_;
    goto * _jitter_back_to_replicated_code_pointer;
  }
#endif // #ifdef JITTER_REPLICATE

    /* Undefine the !REPLACEMENT-tail-call-compiled/n9/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#if    defined(JITTER_DISPATCH_NO_THREADING)         \
    && ! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)
# undef _JITTER_RETURN_ADDRESS
#endif

#ifndef JITTER_REPLICATE
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-tail-call-compiled/n9/retR, _eREPLACEMENT_mtail_mcall_mcompiled__n9__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#endif // #ifndef JITTER_REPLICATE
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for !REPLACEMENT-tail-call-compiled/n9/retR, which started with its
       definitions. */
  }
#endif // #if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
/*  End of !REPLACEMENT-tail-call-compiled/n9/retR , a replacement specialised instruction */

  /* Ordinary specialised instruction !REPLACEMENT-tail-call-compiled/n10/retR (replacement) */
  /* Omit this specialised instruction altogether unless
     replacements are in fact supported in this
     configuration. */
#if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
  JITTER_INSTRUCTION_PROLOG_(!REPLACEMENT-tail-call-compiled/n10/retR, _eREPLACEMENT_mtail_mcall_mcompiled__n10__retR, cold)
  { /* This block begins with definitions for !REPLACEMENT-tail-call-compiled/n10/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       357
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         !REPLACEMENT-tail-call-compiled/n10/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "tail-call-compiled"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "!REPLACEMENT-tail-call-compiled/n10/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _eREPLACEMENT_mtail_mcall_mcompiled__n10__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement and a caller.
       Its 1-th argument, a literal, is the return address where to jump
       back after the procedure returns.  Branch-and-link
       functionality is enabled for this instruction. */
/* This instruction is non-relocatable: use branches which
   cannot ever generate defects. */
#   undef JITTER_BRANCH_AND_LINK
#   define JITTER_BRANCH_AND_LINK      _JITTER_BRANCH_AND_LINK_FALLBACK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   define JITTER_BRANCH_AND_LINK_WITH _JITTER_BRANCH_AND_LINK_WITH_FALLBACK
#   undef JITTER_BRANCH_FAST_AND_LINK
#   define JITTER_BRANCH_FAST_AND_LINK _JITTER_BRANCH_AND_LINK_FALLBACK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1

    /* The 0th argument is a nonresidual literal. */
#   define JITTER_ARG0  ((const union jitter_word){.fixnum = 10L})
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1


#ifdef JITTER_REPLICATE
/* When jumping to the non-relocatable part it is important not
   to use a fallback version of JITTER_COMPUTED_GOTO, in order to
   prevent GCC from tail-merging. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
    /* Jump to non-relocatable code. */
    JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);

    /* Here the residual arity is given as zero: it's too late to
       skip residuals, since we've already jumped and this code is
       unreachable.  The instruction pointer, if any, is advanced
       in the non-relocatable code. */
    JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-tail-call-compiled/n10/retR, _eREPLACEMENT_mtail_mcall_mcompiled__n10__retR, 0)

    /* Relocated code will jump to this label in non-relocated code. */
  JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
    JITTER_COMMENT_IN_ASM_("!REPLACEMENT-tail-call-compiled/n10/retR non-relocatable code");
#endif // #ifdef JITTER_REPLICATE
#if defined(JITTER_DISPATCH_NO_THREADING)             \
    && (! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)  \
        || /* is this a replacement? */ 1)
  /* We use the implicit argument at the end of the calling.
     instruction to discover the procedure return address. */
  const void * const _jitter_return_pointer
    __attribute__ ((unused)) = JITTER_ARGP1;
  /* And make it accessible to the user (who will usually call 
     JITTER_BRANCH_AND_LINK) thru a nice macro. */
# define _JITTER_RETURN_ADDRESS _jitter_return_pointer
#endif

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of !REPLACEMENT-tail-call-compiled/n10/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  no. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
//#if 0
  //fprintf (stderr, "Executing instruction %s..\n", "!REPLACEMENT-tail-call-compiled/n10/retR"); fflush (stderr);
  //fprintf (stderr, "Executing replacement instruction %s..\n", "!REPLACEMENT-tail-call-compiled/n10/retR"); fflush (stderr);
  //fprintf (stderr, "Executing non-relocatable instruction %s with JITTER_SPECIALIZED_INSTRUCTION_WORD_NO=%i..\n", "!REPLACEMENT-tail-call-compiled/n10/retR", (int) JITTER_SPECIALIZED_INSTRUCTION_WORD_NO); fflush (stderr);
  //fprintf (stderr, "Executing caller replcament: _JITTER_RETURN_ADDRESS is %p..\n", _JITTER_RETURN_ADDRESS); fflush (stderr);
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#undef JITTER_THIS_IS_A_REPLACEMENT
#define JITTER_THIS_IS_A_REPLACEMENT 1

    /* User code for !REPLACEMENT-tail-call-compiled/n10/retR . */
  {
/* User-specified code, user code block part: beginning. */

    const jitter_uint in_arity = JITTER_ARGN0;
    jitterlisp_object callee = JITTER_AT_DEPTH_MAINSTACK(in_arity);
    struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(callee);

    /* Here we can assume that * c is a compiled closure without checking. */
    struct jitterlisp_compiled_closure *cc = & c->compiled;

    /* Take the current return address from the return stack: I want to keep
       returning there.  Differently from the case of non-tail calls I don't
       push anything on the return stack: the callee prolog will overwrite
       the current top with a copy of itself, which is fine. */
    jitterlispvm_program_point current_link
      = (jitterlispvm_program_point) JITTER_TOP_RETURNSTACK();

    /* Branch-and-relink to the native code, whose first instruction
       will be a prolog. */
    JITTER_BRANCH_AND_LINK_WITH(cc->first_program_point, current_link);
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for !REPLACEMENT-tail-call-compiled/n10/retR . */

  //fprintf (stderr, "..Executed replacement instruction %s\n", "!REPLACEMENT-tail-call-compiled/n10/retR");
  //fprintf (stderr, "..Executed instruction %s\n", "!REPLACEMENT-tail-call-compiled/n10/retR");
//#endif // #if 0
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
#ifdef JITTER_REPLICATE
  {
    /* Advance the instruction pointer, if any, to skip every
       residual but the last; branch back to replicated
       code. */
    const void *_jitter_back_to_replicated_code_pointer =
      JITTER_ARGP1;
    JITTER_SKIP_RESIDUALS_;
    goto * _jitter_back_to_replicated_code_pointer;
  }
#endif // #ifdef JITTER_REPLICATE

    /* Undefine the !REPLACEMENT-tail-call-compiled/n10/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#if    defined(JITTER_DISPATCH_NO_THREADING)         \
    && ! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)
# undef _JITTER_RETURN_ADDRESS
#endif

#ifndef JITTER_REPLICATE
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-tail-call-compiled/n10/retR, _eREPLACEMENT_mtail_mcall_mcompiled__n10__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#endif // #ifndef JITTER_REPLICATE
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for !REPLACEMENT-tail-call-compiled/n10/retR, which started with its
       definitions. */
  }
#endif // #if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
/*  End of !REPLACEMENT-tail-call-compiled/n10/retR , a replacement specialised instruction */

  /* Ordinary specialised instruction !REPLACEMENT-tail-call-compiled/nR/retR (replacement) */
  /* Omit this specialised instruction altogether unless
     replacements are in fact supported in this
     configuration. */
#if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
  JITTER_INSTRUCTION_PROLOG_(!REPLACEMENT-tail-call-compiled/nR/retR, _eREPLACEMENT_mtail_mcall_mcompiled__nR__retR, cold)
  { /* This block begins with definitions for !REPLACEMENT-tail-call-compiled/nR/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       358
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         !REPLACEMENT-tail-call-compiled/nR/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "tail-call-compiled"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "!REPLACEMENT-tail-call-compiled/nR/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _eREPLACEMENT_mtail_mcall_mcompiled__nR__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is non-relocatable.
       Its 1-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement and a caller.
       Its 1-th argument, a literal, is the return address where to jump
       back after the procedure returns.  Branch-and-link
       functionality is enabled for this instruction. */
/* This instruction is non-relocatable: use branches which
   cannot ever generate defects. */
#   undef JITTER_BRANCH_AND_LINK
#   define JITTER_BRANCH_AND_LINK      _JITTER_BRANCH_AND_LINK_FALLBACK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   define JITTER_BRANCH_AND_LINK_WITH _JITTER_BRANCH_AND_LINK_WITH_FALLBACK
#   undef JITTER_BRANCH_FAST_AND_LINK
#   define JITTER_BRANCH_FAST_AND_LINK _JITTER_BRANCH_AND_LINK_FALLBACK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 2

    /* The 0th argument is a residual literal. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0

    /* The 1th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
    JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
#else
#   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
#   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
#   define JITTER_ARGP1 (JITTER_ARG1.pointer)
#   define JITTER_ARGF1 JITTER_ARGP1


#ifdef JITTER_REPLICATE
/* When jumping to the non-relocatable part it is important not
   to use a fallback version of JITTER_COMPUTED_GOTO, in order to
   prevent GCC from tail-merging. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
    /* Jump to non-relocatable code. */
    JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);

    /* Here the residual arity is given as zero: it's too late to
       skip residuals, since we've already jumped and this code is
       unreachable.  The instruction pointer, if any, is advanced
       in the non-relocatable code. */
    JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-tail-call-compiled/nR/retR, _eREPLACEMENT_mtail_mcall_mcompiled__nR__retR, 0)

    /* Relocated code will jump to this label in non-relocated code. */
  JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
    JITTER_COMMENT_IN_ASM_("!REPLACEMENT-tail-call-compiled/nR/retR non-relocatable code");
#endif // #ifdef JITTER_REPLICATE
#if defined(JITTER_DISPATCH_NO_THREADING)             \
    && (! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)  \
        || /* is this a replacement? */ 1)
  /* We use the implicit argument at the end of the calling.
     instruction to discover the procedure return address. */
  const void * const _jitter_return_pointer
    __attribute__ ((unused)) = JITTER_ARGP1;
  /* And make it accessible to the user (who will usually call 
     JITTER_BRANCH_AND_LINK) thru a nice macro. */
# define _JITTER_RETURN_ADDRESS _jitter_return_pointer
#endif

#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of !REPLACEMENT-tail-call-compiled/nR/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  no. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
//#if 0
  //fprintf (stderr, "Executing instruction %s..\n", "!REPLACEMENT-tail-call-compiled/nR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing replacement instruction %s..\n", "!REPLACEMENT-tail-call-compiled/nR/retR"); fflush (stderr);
  //fprintf (stderr, "Executing non-relocatable instruction %s with JITTER_SPECIALIZED_INSTRUCTION_WORD_NO=%i..\n", "!REPLACEMENT-tail-call-compiled/nR/retR", (int) JITTER_SPECIALIZED_INSTRUCTION_WORD_NO); fflush (stderr);
  //fprintf (stderr, "Executing caller replcament: _JITTER_RETURN_ADDRESS is %p..\n", _JITTER_RETURN_ADDRESS); fflush (stderr);
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#undef JITTER_THIS_IS_A_REPLACEMENT
#define JITTER_THIS_IS_A_REPLACEMENT 1

    /* User code for !REPLACEMENT-tail-call-compiled/nR/retR . */
  {
/* User-specified code, user code block part: beginning. */

    const jitter_uint in_arity = JITTER_ARGN0;
    jitterlisp_object callee = JITTER_AT_DEPTH_MAINSTACK(in_arity);
    struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(callee);

    /* Here we can assume that * c is a compiled closure without checking. */
    struct jitterlisp_compiled_closure *cc = & c->compiled;

    /* Take the current return address from the return stack: I want to keep
       returning there.  Differently from the case of non-tail calls I don't
       push anything on the return stack: the callee prolog will overwrite
       the current top with a copy of itself, which is fine. */
    jitterlispvm_program_point current_link
      = (jitterlispvm_program_point) JITTER_TOP_RETURNSTACK();

    /* Branch-and-relink to the native code, whose first instruction
       will be a prolog. */
    JITTER_BRANCH_AND_LINK_WITH(cc->first_program_point, current_link);
  
/* User-specified code, user code block part: end */

  }
    /* End of the user code for !REPLACEMENT-tail-call-compiled/nR/retR . */

  //fprintf (stderr, "..Executed replacement instruction %s\n", "!REPLACEMENT-tail-call-compiled/nR/retR");
  //fprintf (stderr, "..Executed instruction %s\n", "!REPLACEMENT-tail-call-compiled/nR/retR");
//#endif // #if 0
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
#ifdef JITTER_REPLICATE
  {
    /* Advance the instruction pointer, if any, to skip every
       residual but the last; branch back to replicated
       code. */
    const void *_jitter_back_to_replicated_code_pointer =
      JITTER_ARGP1;
    JITTER_SKIP_RESIDUALS_;
    goto * _jitter_back_to_replicated_code_pointer;
  }
#endif // #ifdef JITTER_REPLICATE

    /* Undefine the !REPLACEMENT-tail-call-compiled/nR/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0
#   undef JITTER_SLOW_REGISTER_OFFSET1
#   undef JITTER_ARG1
#   undef JITTER_ARGN1
#   undef JITTER_ARGU1
#   undef JITTER_ARGP1
#   undef JITTER_ARGF1

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#if    defined(JITTER_DISPATCH_NO_THREADING)         \
    && ! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)
# undef _JITTER_RETURN_ADDRESS
#endif

#ifndef JITTER_REPLICATE
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-tail-call-compiled/nR/retR, _eREPLACEMENT_mtail_mcall_mcompiled__nR__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#endif // #ifndef JITTER_REPLICATE
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for !REPLACEMENT-tail-call-compiled/nR/retR, which started with its
       definitions. */
  }
#endif // #if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
/*  End of !REPLACEMENT-tail-call-compiled/nR/retR , a replacement specialised instruction */

  /* Ordinary specialised instruction !REPLACEMENT-unreachable/retR (replacement) */
  /* Omit this specialised instruction altogether unless
     replacements are in fact supported in this
     configuration. */
#if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
  JITTER_INSTRUCTION_PROLOG_(!REPLACEMENT-unreachable/retR, _eREPLACEMENT_munreachable__retR, cold)
  { /* This block begins with definitions for !REPLACEMENT-unreachable/retR . */
    /* This must be a literal and not the enum case, since
       it will be used in assembly as well. */
#   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       359
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME         !REPLACEMENT-unreachable/retR
#   define JITTER_INSTRUCTION_NAME_AS_STRING "unreachable"
#   define JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING "!REPLACEMENT-unreachable/retR"
#   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _eREPLACEMENT_munreachable__retR

#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
  /* Local poisoning will be in effect.  Avoid warnings. */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic ignored "-Wunknown-warning-option"
# pragma GCC diagnostic ignored "-Wbuiltin-macro-redefined"
# pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

/* Locally poison longjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("longjmp")
# undef longjmp
# define longjmp JITTER_POISONED_EVERYWHERE (longjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef longjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of longjmp . */

/* Locally poison setjmp . */
#if defined (JITTER_HAVE_LOCAL_POISONING)
# pragma push_macro ("setjmp")
# undef setjmp
# define setjmp JITTER_POISONED_EVERYWHERE (setjmp)
#else // ! defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# undef setjmp
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* End of the poisoning of setjmp . */

    /* This specialized instruction is non-relocatable.
       Its 0-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is a replacement. */
    /* This specialized instruction is branching. */
#   undef JITTER_BRANCH_FAST
#   undef JITTER_BRANCH_FAST_IF_ZERO
#   undef JITTER_BRANCH_FAST_IF_NONZERO
#   undef JITTER_BRANCH_FAST_IF_POSITIVE
#   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
#   undef JITTER_BRANCH_FAST_IF_NEGATIVE
#   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
#   undef JITTER_BRANCH_FAST_IF_EQUAL
#   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
#   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
#   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
#   undef JITTER_BRANCH_FAST_IF_AND
#   undef JITTER_BRANCH_FAST_IF_NOTAND
#   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
#   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
#   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
#   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
    /* This specialized instruction is non-relocatable.
       Its 0-th argument, a literal, is the return address where to jump
       at the end, back to relocated code. */

    /* This specialized instruction is not a caller.  Undefine macros only
       visible in caller instructions. */
#   undef JITTER_BRANCH_AND_LINK
#   undef JITTER_BRANCH_AND_LINK_WITH
#   undef JITTER_BRANCH_FAST_AND_LINK

    /* This specialized instruction is not returning.  Undefine macros only
       visible in returning instructions. */
#   undef JITTER_RETURN

    /* This instructions is branching: define branch macros. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#   undef  JITTER_BRANCH
#   define JITTER_BRANCH         _JITTER_BRANCH
#   undef  JITTER_EXIT
#   define JITTER_EXIT           _JITTER_EXIT
  /* The residual arity for this instruction does not depend on fast labels. */
  #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1

    /* The 0th argument is a residual label. */
#if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
    JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
#elif defined (JITTER_REPLICATE)
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
#else
#   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
#endif // #if defined(JITTER_DISPATCH_NO_THREADING)
#   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
#   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
#   define JITTER_ARGP0 (JITTER_ARG0.pointer)
#   define JITTER_ARGF0 JITTER_ARGP0


#ifdef JITTER_REPLICATE
/* When jumping to the non-relocatable part it is important not
   to use a fallback version of JITTER_COMPUTED_GOTO, in order to
   prevent GCC from tail-merging. */
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
    /* Jump to non-relocatable code. */
    JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);

    /* Here the residual arity is given as zero: it's too late to
       skip residuals, since we've already jumped and this code is
       unreachable.  The instruction pointer, if any, is advanced
       in the non-relocatable code. */
    JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-unreachable/retR, _eREPLACEMENT_munreachable__retR, 0)

    /* Relocated code will jump to this label in non-relocated code. */
  JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
    JITTER_COMMENT_IN_ASM_("!REPLACEMENT-unreachable/retR non-relocatable code");
#endif // #ifdef JITTER_REPLICATE
#ifdef JITTER_REPLICATE
/* Define JITTER_COMPUTED_GOTO for the user code of !REPLACEMENT-unreachable/retR ;
   This will be more efficient but potentially defective
   for relocatable instructions, or less efficient but safe for
   non-relocatable instruction.  Is this relocatable?  no. */
#  undef JITTER_COMPUTED_GOTO
#  define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#endif // #ifdef JITTER_REPLICATE
#if defined (JITTERLISPVM_PROFILE_SAMPLE)
  JITTER_PROFILE_SAMPLE_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
# if defined (JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined (JITTER_DISPATCH_NO_THREADING)
   /* Force the compiler not to move sample-profiling instrumentation
      beyond this point; this way the actual user code is timed.
      This is still not perfect, as residuals are materialised before
      we arrive here, but should be adequate at least for slow VM
      instructions.  Unfortunately this is only possible with
      complex dispatches. */
   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
# endif
#endif
#if defined (JITTERLISPVM_PROFILE_COUNT)
  /* Notice that, differently from the code above, this
     instrumentation code *can* be reordered freely: as long as a
     VM instruction is counted, the count increment can be placed
     anyehere.  Let GCC move this code and possibly achieve better
     throughput by exploiting instruction-level parallelism and
     therefore approximate more closely a non-profiled build. */
  JITTER_PROFILE_COUNT_UPDATE
     (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
      JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
#endif

  {
/* User-specified code, instruction-beginning-c part: beginning. */

  
/* User-specified code, instruction-beginning-c part: end */

  }
//#if 0
  //fprintf (stderr, "Executing instruction %s..\n", "!REPLACEMENT-unreachable/retR"); fflush (stderr);
  //fprintf (stderr, "Executing replacement instruction %s..\n", "!REPLACEMENT-unreachable/retR"); fflush (stderr);
  //fprintf (stderr, "Executing non-relocatable instruction %s with JITTER_SPECIALIZED_INSTRUCTION_WORD_NO=%i..\n", "!REPLACEMENT-unreachable/retR", (int) JITTER_SPECIALIZED_INSTRUCTION_WORD_NO); fflush (stderr);
#undef JITTER_THIS_IS_NOT_A_REPLACEMENT
#undef JITTER_THIS_IS_A_REPLACEMENT
#define JITTER_THIS_IS_A_REPLACEMENT 1

    /* User code for !REPLACEMENT-unreachable/retR . */
  {
/* User-specified code, user code block part: beginning. */

/* User-specified code, user code block part: end */

  }
    /* End of the user code for !REPLACEMENT-unreachable/retR . */

  //fprintf (stderr, "..Executed replacement instruction %s\n", "!REPLACEMENT-unreachable/retR");
  //fprintf (stderr, "..Executed instruction %s\n", "!REPLACEMENT-unreachable/retR");
//#endif // #if 0
  {
/* User-specified code, instruction-end-c part: beginning. */

  
/* User-specified code, instruction-end-c part: end */

  }
#ifdef JITTER_REPLICATE
  {
    /* Advance the instruction pointer, if any, to skip every
       residual but the last; branch back to replicated
       code. */
    const void *_jitter_back_to_replicated_code_pointer =
      JITTER_ARGP0;
    JITTER_SKIP_RESIDUALS_;
    goto * _jitter_back_to_replicated_code_pointer;
  }
#endif // #ifdef JITTER_REPLICATE

    /* Undefine the !REPLACEMENT-unreachable/retR argument macros so they can't be used
       by mistake in the instruction body coming next. */
#   undef JITTER_SLOW_REGISTER_OFFSET0
#   undef JITTER_ARG0
#   undef JITTER_ARGN0
#   undef JITTER_ARGU0
#   undef JITTER_ARGP0
#   undef JITTER_ARGF0

#   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
#   undef JITTER_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_NAME_AS_STRING
#   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME

#ifndef JITTER_REPLICATE
#  undef JITTER_COMPUTED_GOTO
#  if defined (JITTER_COMPUTED_GOTO_IN_ASM)
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_IN_ASM
#  else /* JITTER_COMPUTED_GOTO_IN_ASM is not available. */
#    define JITTER_COMPUTED_GOTO JITTER_COMPUTED_GOTO_FALLBACK
#  endif /* if defined (JITTER_COMPUTED_GOTO_IN_ASM) */
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("setjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
# pragma pop_macro ("longjmp")
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
#if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)
/* Local poisoning is no longer in effect.  Revert to the previous
   state of warnings. */
# pragma GCC diagnostic pop
#endif // #if defined (JITTER_HAVE_LOCAL_POISONING_REQUIREMENTS)

 JITTER_INSTRUCTION_EPILOG_(!REPLACEMENT-unreachable/retR, _eREPLACEMENT_munreachable__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
#endif // #ifndef JITTER_REPLICATE
#   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY

    /* Here ends the block for !REPLACEMENT-unreachable/retR, which started with its
       definitions. */
  }
#endif // #if defined (JITTER_HAVE_DEFECT_REPLACEMENT)
/*  End of !REPLACEMENT-unreachable/retR , a replacement specialised instruction */

  /* End of ordinary specialized instructions. */

#ifdef JITTER_DISPATCH_SWITCH
  default:
    jitter_fatal ("invalid opcode %li for VM specialized instruction",
                  (long) jitter_ip->fixnum);
  } /* switch */
#endif // #ifdef JITTER_DISPATCH_SWITCH

  /* The code jumps here when executing the special specialized instruction
     !EXITVM, or on a call to the macro JITTER_EXIT from an ordinary specialized
     instruction.  This code is *not* replicated: when replication is enabled
     jumping here means crossing the boundary from the fragaile replicated
     code back into ordinary compiled C, where PC-relative addressing works. */
  jitter_exit_vm_label: __attribute__ ((cold));
    JITTER_COMMENT_IN_ASM_("About to exit the function");
    // fprintf (stderr, "Restoring the VM state to the struct...\n");

#if defined (JITTERLISPVM_PROFILE_SAMPLE)
    /* Stop sample-profiling: this stops the periodic timer signal, while
       we are no longer updating the current instruction field within the
       special-purpose struct in the Array. */
    jitterlispvm_profile_sample_stop ();
#endif // #if defined (JITTERLISPVM_PROFILE_SAMPLE)
# if defined(JITTER_DISPATCH_MINIMAL_THREADING) \
     || defined(JITTER_DISPATCH_NO_THREADING)
  /* Execute architecture-specific execution-end code, if any.  Make 
     sure it is safe to expand the macro without do..while (false). */
  {}; JITTER_EXECUTION_END_; {};
# endif

  //fprintf (stderr, "still alive at the end of VM code: no-threading code compiled with GCC 4 runs VM code with success then crashes here.\n");

    /* Copy the VM state from the local copy we have modified back to
       the structure to which we received a pointer. */
    jitter_original_state->_jitterlispvm_1TbNcL3hel_state_runtime = jitter_state_runtime;

    // fprintf (stderr, "Exiting the VM...\n");

  /* Finalization C code from the user */

  
  /* End of the finalization C code from the user */


  /* This program point is reachable for both thread initialization and
     execution.  In either case it is not performance-critical. */
  jitter_possibly_restore_registers_and_return_label: __attribute__ ((cold));
    //if (jitter_initialize) puts ("-- RETURNING FROM INITIALIZATION\n");
#ifdef JITTER_DISPATCH_NO_THREADING
    /* Back to regular C without our reserved registers: restore the
       values held in such registers at entry. */
    jitterlispvm_restore_registers (jitter_register_buffer);
#endif // #ifdef JITTER_DISPATCH_NO_THREADING

  /* Update the state exit status. */
  if (! jitter_initialize)
    _JITTER_STATE_BACKING_FIELD (exit_status)
      = jitterlispvm_exit_status_exited;

  /* We are done.  If initialising return some arbitrary result,
     otherwise (which is the interesting case) return the exit
     status from the VM state. */
  if (jitter_initialize)
    return jitterlispvm_exit_status_never_executed;
  else
    return _JITTER_STATE_BACKING_FIELD (exit_status);
}
__attribute__ ((noinline, noclone, no_reorder))
void
jitterlispvm_asm_footers (void)
{
#ifndef JITTER_DISPATCH_SWITCH
  JITTER_DATA_LOCATION_FOOTER(jitterlispvm);
#endif // #ifndef JITTER_DISPATCH_SWITCH
#ifdef JITTER_HAVE_DEFECT_REPLACEMENT
  /* Close the defect global definition for this executor.  This defines a
     new global in the defect subsection, holding the descriptor number.
     This is a global asm statement. */
  JITTER_DEFECT_FOOTER(jitterlispvm);
#endif // #ifdef JITTER_HAVE_DEFECT_REPLACEMENT

#ifdef JITTER_HAVE_PATCH_IN
  /* The same as for defects, here for patch-ins. */
  JITTER_PATCH_IN_FOOTER(jitterlispvm);
#endif // #ifdef JITTER_HAVE_PATCH_IN

}
