struct cam8_struct {

  struct port_struct {

    struct steplist_struct {

      struct heap_struct {
	LL pglst;             /* list of pages */

	struct page_struct {
	  /* pointers to the page in user, kernel and interface address space */
	  char *usr, *ker, *ifc;
	  int sz;               /* size of actual page */
	  char *free;           /* pointer to first free byte */
	  int bytes;            /* number of usable bytes in page */
	  int koff, ioff;       /* offset to add for kernel, interface addresses */
	} *ffp;             /* first free page */

	int sz;               /* num pages in heap */
	int bytes;            /* num bytes free in current page */
	int dyn;              /* boolean: allocate more pages? */
	int camfd;            /* fd for device driver */
      } *mem;          /* ptr to the heap which holds the sl */

      struct instr_struct {

	struct buffer_struct {
	  char *ptr;       /* ptr to the actual data */
	  int sz, kersz;   /* size of usable buffer area, real size of buffer */
	  int koff, ioff;  /* offsets to kernel and interace addresses */
	  int camfd;       /* /dev/cam fd */

	  struct heap_struct {
	    LL pglst;             /* list of pages */

	    struct page_struct {
	      /* pointers to the page in user, kernel and interface address space */
	      char *usr, *ker, *ifc;
	      int sz;               /* size of actual page */
	      char *free;           /* pointer to first free byte */
	      int bytes;            /* number of usable bytes in page */
	      int koff, ioff;       /* offset to add for kernel, interface addresses */
	    } *ffp;             /* first free page */

	    int sz;               /* num pages in heap */
	    int bytes;            /* num bytes free in current page */
	    int dyn;              /* boolean: allocate more pages? */
	    int camfd;            /* fd for device driver */
	  } *hp;	   /* pointer to heap if buffer was allocate from one */

	} *sle;

	struct buffer_struct {
	  char *ptr;       /* ptr to the actual data */
	  int sz, kersz;   /* size of usable buffer area, real size of buffer */
	  int koff, ioff;  /* offsets to kernel and interace addresses */
	  int camfd;       /* /dev/cam fd */

	  struct heap_struct {
	    LL pglst;             /* list of pages */

	    struct page_struct {
	      /* pointers to the page in user, kernel and interface address space */
	      char *usr, *ker, *ifc;
	      int sz;               /* size of actual page */
	      char *free;           /* pointer to first free byte */
	      int bytes;            /* number of usable bytes in page */
	      int koff, ioff;       /* offset to add for kernel, interface addresses */
	    } *ffp;             /* first free page */

	    int sz;               /* num pages in heap */
	    int bytes;            /* num bytes free in current page */
	    int dyn;              /* boolean: allocate more pages? */
	    int camfd;            /* fd for device driver */
	  } *hp;	   /* pointer to heap if buffer was allocate from one */

	} *usr_buf;

	struct buffer_struct {
	  char *ptr;       /* ptr to the actual data */
	  int sz, kersz;   /* size of usable buffer area, real size of buffer */
	  int koff, ioff;  /* offsets to kernel and interace addresses */
	  int camfd;       /* /dev/cam fd */

	  struct heap_struct {
	    LL pglst;             /* list of pages */

	    struct page_struct {
	      /* pointers to the page in user, kernel and interface address space */
	      char *usr, *ker, *ifc;
	      int sz;               /* size of actual page */
	      char *free;           /* pointer to first free byte */
	      int bytes;            /* number of usable bytes in page */
	      int koff, ioff;       /* offset to add for kernel, interface addresses */
	    } *ffp;             /* first free page */

	    int sz;               /* num pages in heap */
	    int bytes;            /* num bytes free in current page */
	    int dyn;              /* boolean: allocate more pages? */
	    int camfd;            /* fd for device driver */
	  } *hp;	   /* pointer to heap if buffer was allocate from one */

	} *def_buf;

	struct heap_struct {
	  LL pglst;             /* list of pages */

	  struct page_struct {
	    /* pointers to the page in user, kernel and interface address space */
	    char *usr, *ker, *ifc;
	    int sz;               /* size of actual page */
	    char *free;           /* pointer to first free byte */
	    int bytes;            /* number of usable bytes in page */
	    int koff, ioff;       /* offset to add for kernel, interface addresses */
	  } *ffp;             /* first free page */

	  int sz;               /* num pages in heap */
	  int bytes;            /* num bytes free in current page */
	  int dyn;              /* boolean: allocate more pages? */
	  int camfd;            /* fd for device driver */
	} *hp;

	int regnum, buflen;
      } *list;          /* ptr to the first instruction       */

      struct instr_struct {

	struct buffer_struct {
	  char *ptr;       /* ptr to the actual data */
	  int sz, kersz;   /* size of usable buffer area, real size of buffer */
	  int koff, ioff;  /* offsets to kernel and interace addresses */
	  int camfd;       /* /dev/cam fd */

	  struct heap_struct {
	    LL pglst;             /* list of pages */

	    struct page_struct {
	      /* pointers to the page in user, kernel and interface address space */
	      char *usr, *ker, *ifc;
	      int sz;               /* size of actual page */
	      char *free;           /* pointer to first free byte */
	      int bytes;            /* number of usable bytes in page */
	      int koff, ioff;       /* offset to add for kernel, interface addresses */
	    } *ffp;             /* first free page */

	    int sz;               /* num pages in heap */
	    int bytes;            /* num bytes free in current page */
	    int dyn;              /* boolean: allocate more pages? */
	    int camfd;            /* fd for device driver */
	  } *hp;	   /* pointer to heap if buffer was allocate from one */

	} *sle;

	struct buffer_struct {
	  char *ptr;       /* ptr to the actual data */
	  int sz, kersz;   /* size of usable buffer area, real size of buffer */
	  int koff, ioff;  /* offsets to kernel and interace addresses */
	  int camfd;       /* /dev/cam fd */

	  struct heap_struct {
	    LL pglst;             /* list of pages */

	    struct page_struct {
	      /* pointers to the page in user, kernel and interface address space */
	      char *usr, *ker, *ifc;
	      int sz;               /* size of actual page */
	      char *free;           /* pointer to first free byte */
	      int bytes;            /* number of usable bytes in page */
	      int koff, ioff;       /* offset to add for kernel, interface addresses */
	    } *ffp;             /* first free page */

	    int sz;               /* num pages in heap */
	    int bytes;            /* num bytes free in current page */
	    int dyn;              /* boolean: allocate more pages? */
	    int camfd;            /* fd for device driver */
	  } *hp;	   /* pointer to heap if buffer was allocate from one */

	} *usr_buf;

	struct buffer_struct {
	  char *ptr;       /* ptr to the actual data */
	  int sz, kersz;   /* size of usable buffer area, real size of buffer */
	  int koff, ioff;  /* offsets to kernel and interace addresses */
	  int camfd;       /* /dev/cam fd */

	  struct heap_struct {
	    LL pglst;             /* list of pages */

	    struct page_struct {
	      /* pointers to the page in user, kernel and interface address space */
	      char *usr, *ker, *ifc;
	      int sz;               /* size of actual page */
	      char *free;           /* pointer to first free byte */
	      int bytes;            /* number of usable bytes in page */
	      int koff, ioff;       /* offset to add for kernel, interface addresses */
	    } *ffp;             /* first free page */

	    int sz;               /* num pages in heap */
	    int bytes;            /* num bytes free in current page */
	    int dyn;              /* boolean: allocate more pages? */
	    int camfd;            /* fd for device driver */
	  } *hp;	   /* pointer to heap if buffer was allocate from one */

	} *def_buf;

	struct heap_struct {
	  LL pglst;             /* list of pages */

	  struct page_struct {
	    /* pointers to the page in user, kernel and interface address space */
	    char *usr, *ker, *ifc;
	    int sz;               /* size of actual page */
	    char *free;           /* pointer to first free byte */
	    int bytes;            /* number of usable bytes in page */
	    int koff, ioff;       /* offset to add for kernel, interface addresses */
	  } *ffp;             /* first free page */

	  int sz;               /* num pages in heap */
	  int bytes;            /* num bytes free in current page */
	  int dyn;              /* boolean: allocate more pages? */
	  int camfd;            /* fd for device driver */
	} *hp;

	int regnum, buflen;
      } *prev_instr;  /* ptr to the previous instr   ??     */

      struct instr_struct {

	struct buffer_struct {
	  char *ptr;       /* ptr to the actual data */
	  int sz, kersz;   /* size of usable buffer area, real size of buffer */
	  int koff, ioff;  /* offsets to kernel and interace addresses */
	  int camfd;       /* /dev/cam fd */

	  struct heap_struct {
	    LL pglst;             /* list of pages */

	    struct page_struct {
	      /* pointers to the page in user, kernel and interface address space */
	      char *usr, *ker, *ifc;
	      int sz;               /* size of actual page */
	      char *free;           /* pointer to first free byte */
	      int bytes;            /* number of usable bytes in page */
	      int koff, ioff;       /* offset to add for kernel, interface addresses */
	    } *ffp;             /* first free page */

	    int sz;               /* num pages in heap */
	    int bytes;            /* num bytes free in current page */
	    int dyn;              /* boolean: allocate more pages? */
	    int camfd;            /* fd for device driver */
	  } *hp;	   /* pointer to heap if buffer was allocate from one */

	} *sle;

	struct buffer_struct {
	  char *ptr;       /* ptr to the actual data */
	  int sz, kersz;   /* size of usable buffer area, real size of buffer */
	  int koff, ioff;  /* offsets to kernel and interace addresses */
	  int camfd;       /* /dev/cam fd */

	  struct heap_struct {
	    LL pglst;             /* list of pages */

	    struct page_struct {
	      /* pointers to the page in user, kernel and interface address space */
	      char *usr, *ker, *ifc;
	      int sz;               /* size of actual page */
	      char *free;           /* pointer to first free byte */
	      int bytes;            /* number of usable bytes in page */
	      int koff, ioff;       /* offset to add for kernel, interface addresses */
	    } *ffp;             /* first free page */

	    int sz;               /* num pages in heap */
	    int bytes;            /* num bytes free in current page */
	    int dyn;              /* boolean: allocate more pages? */
	    int camfd;            /* fd for device driver */
	  } *hp;	   /* pointer to heap if buffer was allocate from one */

	} *usr_buf;

	struct buffer_struct {
	  char *ptr;       /* ptr to the actual data */
	  int sz, kersz;   /* size of usable buffer area, real size of buffer */
	  int koff, ioff;  /* offsets to kernel and interace addresses */
	  int camfd;       /* /dev/cam fd */

	  struct heap_struct {
	    LL pglst;             /* list of pages */

	    struct page_struct {
	      /* pointers to the page in user, kernel and interface address space */
	      char *usr, *ker, *ifc;
	      int sz;               /* size of actual page */
	      char *free;           /* pointer to first free byte */
	      int bytes;            /* number of usable bytes in page */
	      int koff, ioff;       /* offset to add for kernel, interface addresses */
	    } *ffp;             /* first free page */

	    int sz;               /* num pages in heap */
	    int bytes;            /* num bytes free in current page */
	    int dyn;              /* boolean: allocate more pages? */
	    int camfd;            /* fd for device driver */
	  } *hp;	   /* pointer to heap if buffer was allocate from one */

	} *def_buf;

	struct heap_struct {
	  LL pglst;             /* list of pages */

	  struct page_struct {
	    /* pointers to the page in user, kernel and interface address space */
	    char *usr, *ker, *ifc;
	    int sz;               /* size of actual page */
	    char *free;           /* pointer to first free byte */
	    int bytes;            /* number of usable bytes in page */
	    int koff, ioff;       /* offset to add for kernel, interface addresses */
	  } *ffp;             /* first free page */

	  int sz;               /* num pages in heap */
	  int bytes;            /* num bytes free in current page */
	  int dyn;              /* boolean: allocate more pages? */
	  int camfd;            /* fd for device driver */
	} *hp;

	int regnum, buflen;
      } *jump_point;

      int nested_link;
      int camfd, length; /* length in instructions (?) */
      int head, link, jump;
    } *prev;

    struct steplist_struct {

      struct heap_struct {
	LL pglst;             /* list of pages */

	struct page_struct {
	  /* pointers to the page in user, kernel and interface address space */
	  char *usr, *ker, *ifc;
	  int sz;               /* size of actual page */
	  char *free;           /* pointer to first free byte */
	  int bytes;            /* number of usable bytes in page */
	  int koff, ioff;       /* offset to add for kernel, interface addresses */
	} *ffp;             /* first free page */

	int sz;               /* num pages in heap */
	int bytes;            /* num bytes free in current page */
	int dyn;              /* boolean: allocate more pages? */
	int camfd;            /* fd for device driver */
      } *mem;          /* ptr to the heap which holds the sl */

      struct instr_struct {

	struct buffer_struct {
	  char *ptr;       /* ptr to the actual data */
	  int sz, kersz;   /* size of usable buffer area, real size of buffer */
	  int koff, ioff;  /* offsets to kernel and interace addresses */
	  int camfd;       /* /dev/cam fd */

	  struct heap_struct {
	    LL pglst;             /* list of pages */

	    struct page_struct {
	      /* pointers to the page in user, kernel and interface address space */
	      char *usr, *ker, *ifc;
	      int sz;               /* size of actual page */
	      char *free;           /* pointer to first free byte */
	      int bytes;            /* number of usable bytes in page */
	      int koff, ioff;       /* offset to add for kernel, interface addresses */
	    } *ffp;             /* first free page */

	    int sz;               /* num pages in heap */
	    int bytes;            /* num bytes free in current page */
	    int dyn;              /* boolean: allocate more pages? */
	    int camfd;            /* fd for device driver */
	  } *hp;	   /* pointer to heap if buffer was allocate from one */

	} *sle;

	struct buffer_struct {
	  char *ptr;       /* ptr to the actual data */
	  int sz, kersz;   /* size of usable buffer area, real size of buffer */
	  int koff, ioff;  /* offsets to kernel and interace addresses */
	  int camfd;       /* /dev/cam fd */

	  struct heap_struct {
	    LL pglst;             /* list of pages */

	    struct page_struct {
	      /* pointers to the page in user, kernel and interface address space */
	      char *usr, *ker, *ifc;
	      int sz;               /* size of actual page */
	      char *free;           /* pointer to first free byte */
	      int bytes;            /* number of usable bytes in page */
	      int koff, ioff;       /* offset to add for kernel, interface addresses */
	    } *ffp;             /* first free page */

	    int sz;               /* num pages in heap */
	    int bytes;            /* num bytes free in current page */
	    int dyn;              /* boolean: allocate more pages? */
	    int camfd;            /* fd for device driver */
	  } *hp;	   /* pointer to heap if buffer was allocate from one */

	} *usr_buf;

	struct buffer_struct {
	  char *ptr;       /* ptr to the actual data */
	  int sz, kersz;   /* size of usable buffer area, real size of buffer */
	  int koff, ioff;  /* offsets to kernel and interace addresses */
	  int camfd;       /* /dev/cam fd */

	  struct heap_struct {
	    LL pglst;             /* list of pages */

	    struct page_struct {
	      /* pointers to the page in user, kernel and interface address space */
	      char *usr, *ker, *ifc;
	      int sz;               /* size of actual page */
	      char *free;           /* pointer to first free byte */
	      int bytes;            /* number of usable bytes in page */
	      int koff, ioff;       /* offset to add for kernel, interface addresses */
	    } *ffp;             /* first free page */

	    int sz;               /* num pages in heap */
	    int bytes;            /* num bytes free in current page */
	    int dyn;              /* boolean: allocate more pages? */
	    int camfd;            /* fd for device driver */
	  } *hp;	   /* pointer to heap if buffer was allocate from one */

	} *def_buf;

	struct heap_struct {
	  LL pglst;             /* list of pages */

	  struct page_struct {
	    /* pointers to the page in user, kernel and interface address space */
	    char *usr, *ker, *ifc;
	    int sz;               /* size of actual page */
	    char *free;           /* pointer to first free byte */
	    int bytes;            /* number of usable bytes in page */
	    int koff, ioff;       /* offset to add for kernel, interface addresses */
	  } *ffp;             /* first free page */

	  int sz;               /* num pages in heap */
	  int bytes;            /* num bytes free in current page */
	  int dyn;              /* boolean: allocate more pages? */
	  int camfd;            /* fd for device driver */
	} *hp;

	int regnum, buflen;
      } *list;          /* ptr to the first instruction       */

      struct instr_struct {

	struct buffer_struct {
	  char *ptr;       /* ptr to the actual data */
	  int sz, kersz;   /* size of usable buffer area, real size of buffer */
	  int koff, ioff;  /* offsets to kernel and interace addresses */
	  int camfd;       /* /dev/cam fd */

	  struct heap_struct {
	    LL pglst;             /* list of pages */

	    struct page_struct {
	      /* pointers to the page in user, kernel and interface address space */
	      char *usr, *ker, *ifc;
	      int sz;               /* size of actual page */
	      char *free;           /* pointer to first free byte */
	      int bytes;            /* number of usable bytes in page */
	      int koff, ioff;       /* offset to add for kernel, interface addresses */
	    } *ffp;             /* first free page */

	    int sz;               /* num pages in heap */
	    int bytes;            /* num bytes free in current page */
	    int dyn;              /* boolean: allocate more pages? */
	    int camfd;            /* fd for device driver */
	  } *hp;	   /* pointer to heap if buffer was allocate from one */

	} *sle;

	struct buffer_struct {
	  char *ptr;       /* ptr to the actual data */
	  int sz, kersz;   /* size of usable buffer area, real size of buffer */
	  int koff, ioff;  /* offsets to kernel and interace addresses */
	  int camfd;       /* /dev/cam fd */

	  struct heap_struct {
	    LL pglst;             /* list of pages */

	    struct page_struct {
	      /* pointers to the page in user, kernel and interface address space */
	      char *usr, *ker, *ifc;
	      int sz;               /* size of actual page */
	      char *free;           /* pointer to first free byte */
	      int bytes;            /* number of usable bytes in page */
	      int koff, ioff;       /* offset to add for kernel, interface addresses */
	    } *ffp;             /* first free page */

	    int sz;               /* num pages in heap */
	    int bytes;            /* num bytes free in current page */
	    int dyn;              /* boolean: allocate more pages? */
	    int camfd;            /* fd for device driver */
	  } *hp;	   /* pointer to heap if buffer was allocate from one */

	} *usr_buf;

	struct buffer_struct {
	  char *ptr;       /* ptr to the actual data */
	  int sz, kersz;   /* size of usable buffer area, real size of buffer */
	  int koff, ioff;  /* offsets to kernel and interace addresses */
	  int camfd;       /* /dev/cam fd */

	  struct heap_struct {
	    LL pglst;             /* list of pages */

	    struct page_struct {
	      /* pointers to the page in user, kernel and interface address space */
	      char *usr, *ker, *ifc;
	      int sz;               /* size of actual page */
	      char *free;           /* pointer to first free byte */
	      int bytes;            /* number of usable bytes in page */
	      int koff, ioff;       /* offset to add for kernel, interface addresses */
	    } *ffp;             /* first free page */

	    int sz;               /* num pages in heap */
	    int bytes;            /* num bytes free in current page */
	    int dyn;              /* boolean: allocate more pages? */
	    int camfd;            /* fd for device driver */
	  } *hp;	   /* pointer to heap if buffer was allocate from one */

	} *def_buf;

	struct heap_struct {
	  LL pglst;             /* list of pages */

	  struct page_struct {
	    /* pointers to the page in user, kernel and interface address space */
	    char *usr, *ker, *ifc;
	    int sz;               /* size of actual page */
	    char *free;           /* pointer to first free byte */
	    int bytes;            /* number of usable bytes in page */
	    int koff, ioff;       /* offset to add for kernel, interface addresses */
	  } *ffp;             /* first free page */

	  int sz;               /* num pages in heap */
	  int bytes;            /* num bytes free in current page */
	  int dyn;              /* boolean: allocate more pages? */
	  int camfd;            /* fd for device driver */
	} *hp;
	int regnum, buflen;

      } *prev_instr;  /* ptr to the previous instr   ??     */

      struct instr_struct {

	struct buffer_struct {
	  char *ptr;       /* ptr to the actual data */
	  int sz, kersz;   /* size of usable buffer area, real size of buffer */
	  int koff, ioff;  /* offsets to kernel and interace addresses */
	  int camfd;       /* /dev/cam fd */

	  struct heap_struct {
	    LL pglst;             /* list of pages */

	    struct page_struct {
	      /* pointers to the page in user, kernel and interface address space */
	      char *usr, *ker, *ifc;
	      int sz;               /* size of actual page */
	      char *free;           /* pointer to first free byte */
	      int bytes;            /* number of usable bytes in page */
	      int koff, ioff;       /* offset to add for kernel, interface addresses */
	    } *ffp;             /* first free page */

	    int sz;               /* num pages in heap */
	    int bytes;            /* num bytes free in current page */
	    int dyn;              /* boolean: allocate more pages? */
	    int camfd;            /* fd for device driver */
	  } *hp;	   /* pointer to heap if buffer was allocate from one */

	} *sle;

	struct buffer_struct {
	  char *ptr;       /* ptr to the actual data */
	  int sz, kersz;   /* size of usable buffer area, real size of buffer */
	  int koff, ioff;  /* offsets to kernel and interace addresses */
	  int camfd;       /* /dev/cam fd */

	  struct heap_struct {
	    LL pglst;             /* list of pages */

	    struct page_struct {
	      /* pointers to the page in user, kernel and interface address space */
	      char *usr, *ker, *ifc;
	      int sz;               /* size of actual page */
	      char *free;           /* pointer to first free byte */
	      int bytes;            /* number of usable bytes in page */
	      int koff, ioff;       /* offset to add for kernel, interface addresses */
	    } *ffp;             /* first free page */

	    int sz;               /* num pages in heap */
	    int bytes;            /* num bytes free in current page */
	    int dyn;              /* boolean: allocate more pages? */
	    int camfd;            /* fd for device driver */
	  } *hp;	   /* pointer to heap if buffer was allocate from one */

	} *usr_buf;

	struct buffer_struct {
	  char *ptr;       /* ptr to the actual data */
	  int sz, kersz;   /* size of usable buffer area, real size of buffer */
	  int koff, ioff;  /* offsets to kernel and interace addresses */
	  int camfd;       /* /dev/cam fd */

	  struct heap_struct {
	    LL pglst;             /* list of pages */

	    struct page_struct {
	      /* pointers to the page in user, kernel and interface address space */
	      char *usr, *ker, *ifc;
	      int sz;               /* size of actual page */
	      char *free;           /* pointer to first free byte */
	      int bytes;            /* number of usable bytes in page */
	      int koff, ioff;       /* offset to add for kernel, interface addresses */
	    } *ffp;             /* first free page */

	    int sz;               /* num pages in heap */
	    int bytes;            /* num bytes free in current page */
	    int dyn;              /* boolean: allocate more pages? */
	    int camfd;            /* fd for device driver */
	  } *hp;	   /* pointer to heap if buffer was allocate from one */

	} *def_buf;

	struct heap_struct {
	  LL pglst;             /* list of pages */

	  struct page_struct {
	    /* pointers to the page in user, kernel and interface address space */
	    char *usr, *ker, *ifc;
	    int sz;               /* size of actual page */
	    char *free;           /* pointer to first free byte */
	    int bytes;            /* number of usable bytes in page */
	    int koff, ioff;       /* offset to add for kernel, interface addresses */
	  } *ffp;             /* first free page */

	  int sz;               /* num pages in heap */
	  int bytes;            /* num bytes free in current page */
	  int dyn;              /* boolean: allocate more pages? */
	  int camfd;            /* fd for device driver */
	} *hp;

	int regnum, buflen;
      } *jump_point;

      int nested_link;
      int camfd, length; /* length in instructions (?) */
      int head, link, jump;
    } *cur;             /* steplists to send */

    int last_ints;                                  /* ? */
    int camint_was_seen, timeout_was_seen;      /* bools */
    int timeout_is_allowed, camint_is_allowed;  /* bools */
  } *pt;

  struct c8mach_struct {
    unsigned int num_modules;
    unsigned int num[3];
    unsigned int num_layers, num_levels;
    unsigned int maxid;
    unsigned int dram_size, dram_row;
    unsigned int flush_delay;
    unsigned int scan_io_delay;
    unsigned int clocks_per_refresh;
    unsigned int sweep_overhead;
    unsigned int lut_len;
  } *mp;               /* ptr to the hardware data */

  struct heap_struct {
    LL pglst;             /* list of pages */

    struct page_struct {
      /* pointers to the page in user, kernel and interface address space */
      char *usr, *ker, *ifc;
      int sz;               /* size of actual page */
      char *free;           /* pointer to first free byte */
      int bytes;            /* number of usable bytes in page */
      int koff, ioff;       /* offset to add for kernel, interface addresses */
    } *ffp;             /* first free page */

    int sz;               /* num pages in heap */
    int bytes;            /* num bytes free in current page */
    int dyn;              /* boolean: allocate more pages? */
    int camfd;            /* fd for device driver */
  } *hp;

  struct space_struct {

    struct spc_state {
      int extents[24];         /* size of dimension in sites */
      unsigned short len[24];  /* bit length of dim */
      unsigned short pos[24];  /* bit positn of dim in Kick Reg */
      int num_dim, top_dim, dmask, num_cells;
    } space;           /* the whole experiment space */

    struct spc_state {
      int extents[24];         /* size of dimension in sites */
      unsigned short len[24];  /* bit length of dim */
      unsigned short pos[24];  /* bit positn of dim in Kick Reg */
      int num_dim, top_dim, dmask, num_cells;
    } subspace;        /* a part of the experiment space */

    struct spc_state {
      int extents[24];         /* size of dimension in sites */
      unsigned short len[24];  /* bit length of dim */
      unsigned short pos[24];  /* bit positn of dim in Kick Reg */
      int num_dim, top_dim, dmask, num_cells;
    } sector;          /* the space contained in 1 module */

    struct spc_state {
      int extents[24];         /* size of dimension in sites */
      unsigned short len[24];  /* bit length of dim */
      unsigned short pos[24];  /* bit positn of dim in Kick Reg */
      int num_dim, top_dim, dmask, num_cells;
    } subsector;       /* a section of a module */

    int glue[3];
    int num_modules[3];
    unsigned char module_xyz_list[8];
  } *spc;               /* ptr to the abstract space */

  struct subcell_struct {

    struct buffer_struct {
      char *ptr;       /* ptr to the actual data */
      int sz, kersz;   /* size of usable buffer area, real size of buffer */
      int koff, ioff;  /* offsets to kernel and interace addresses */
      int camfd;       /* /dev/cam fd */

      struct heap_struct {
	LL pglst;             /* list of pages */

	struct page_struct {
	  /* pointers to the page in user, kernel and interface address space */
	  char *usr, *ker, *ifc;
	  int sz;               /* size of actual page */
	  char *free;           /* pointer to first free byte */
	  int bytes;            /* number of usable bytes in page */
	  int koff, ioff;       /* offset to add for kernel, interface addresses */
	} *ffp;             /* first free page */

	int sz;               /* num pages in heap */
	int bytes;            /* num bytes free in current page */
	int dyn;              /* boolean: allocate more pages? */
	int camfd;            /* fd for device driver */
      } *hp;	   /* pointer to heap if buffer was allocate from one */

    } *offset[SCTBL_SZ];

    int max_subcell_declared, declared_subcell_num;
    int assemble_subcell_num;
  } *sc;              /* ptr to the subcell configuration */

  struct defaults_struct {
    int defining_defaults;   /* boolean: are we defining? */

    struct buffer_struct {
      char *ptr;       /* ptr to the actual data */
      int sz, kersz;   /* size of usable buffer area, real size of buffer */
      int koff, ioff;  /* offsets to kernel and interace addresses */
      int camfd;       /* /dev/cam fd */

      struct heap_struct {
	LL pglst;             /* list of pages */

	struct page_struct {
	  /* pointers to the page in user, kernel and interface address space */
	  char *usr, *ker, *ifc;
	  int sz;               /* size of actual page */
	  char *free;           /* pointer to first free byte */
	  int bytes;            /* number of usable bytes in page */
	  int koff, ioff;       /* offset to add for kernel, interface addresses */
	} *ffp;             /* first free page */

	int sz;               /* num pages in heap */
	int bytes;            /* num bytes free in current page */
	int dyn;              /* boolean: allocate more pages? */
	int camfd;            /* fd for device driver */
      } *hp;	   /* pointer to heap if buffer was allocate from one */

    } *std[29];           /* standard defaults */

    struct buffer_struct {
      char *ptr;       /* ptr to the actual data */
      int sz, kersz;   /* size of usable buffer area, real size of buffer */
      int koff, ioff;  /* offsets to kernel and interace addresses */
      int camfd;       /* /dev/cam fd */

      struct heap_struct {
	LL pglst;             /* list of pages */

	struct page_struct {
	  /* pointers to the page in user, kernel and interface address space */
	  char *usr, *ker, *ifc;
	  int sz;               /* size of actual page */
	  char *free;           /* pointer to first free byte */
	  int bytes;            /* number of usable bytes in page */
	  int koff, ioff;       /* offset to add for kernel, interface addresses */
	} *ffp;             /* first free page */

	int sz;               /* num pages in heap */
	int bytes;            /* num bytes free in current page */
	int dyn;              /* boolean: allocate more pages? */
	int camfd;            /* fd for device driver */
      } *hp;	   /* pointer to heap if buffer was allocate from one */

    } *my[29];            /* user set defaults */

    struct buffer_struct {
      char *ptr;       /* ptr to the actual data */
      int sz, kersz;   /* size of usable buffer area, real size of buffer */
      int koff, ioff;  /* offsets to kernel and interace addresses */
      int camfd;       /* /dev/cam fd */

      struct heap_struct {
	LL pglst;             /* list of pages */

	struct page_struct {
	  /* pointers to the page in user, kernel and interface address space */
	  char *usr, *ker, *ifc;
	  int sz;               /* size of actual page */
	  char *free;           /* pointer to first free byte */
	  int bytes;            /* number of usable bytes in page */
	  int koff, ioff;       /* offset to add for kernel, interface addresses */
	} *ffp;             /* first free page */

	int sz;               /* num pages in heap */
	int bytes;            /* num bytes free in current page */
	int dyn;              /* boolean: allocate more pages? */
	int camfd;            /* fd for device driver */
      } *hp;	   /* pointer to heap if buffer was allocate from one */

    } **defbuf;

    struct heap_struct {
      LL pglst;             /* list of pages */

      struct page_struct {
	/* pointers to the page in user, kernel and interface address space */
	char *usr, *ker, *ifc;
	int sz;               /* size of actual page */
	char *free;           /* pointer to first free byte */
	int bytes;            /* number of usable bytes in page */
	int koff, ioff;       /* offset to add for kernel, interface addresses */
      } *ffp;             /* first free page */

      int sz;               /* num pages in heap */
      int bytes;            /* num bytes free in current page */
      int dyn;              /* boolean: allocate more pages? */
      int camfd;            /* fd for device driver */
    } *hp;

    struct instr_struct {

      struct buffer_struct {
	char *ptr;       /* ptr to the actual data */
	int sz, kersz;   /* size of usable buffer area, real size of buffer */
	int koff, ioff;  /* offsets to kernel and interace addresses */
	int camfd;       /* /dev/cam fd */

	struct heap_struct {
	  LL pglst;             /* list of pages */

	  struct page_struct {
	    /* pointers to the page in user, kernel and interface address space */
	    char *usr, *ker, *ifc;
	    int sz;               /* size of actual page */
	    char *free;           /* pointer to first free byte */
	    int bytes;            /* number of usable bytes in page */
	    int koff, ioff;       /* offset to add for kernel, interface addresses */
	  } *ffp;             /* first free page */

	  int sz;               /* num pages in heap */
	  int bytes;            /* num bytes free in current page */
	  int dyn;              /* boolean: allocate more pages? */
	  int camfd;            /* fd for device driver */
	} *hp;	   /* pointer to heap if buffer was allocate from one */

      } *sle;

      struct buffer_struct {
	char *ptr;       /* ptr to the actual data */
	int sz, kersz;   /* size of usable buffer area, real size of buffer */
	int koff, ioff;  /* offsets to kernel and interace addresses */
	int camfd;       /* /dev/cam fd */

	struct heap_struct {
	  LL pglst;             /* list of pages */

	  struct page_struct {
	    /* pointers to the page in user, kernel and interface address space */
	    char *usr, *ker, *ifc;
	    int sz;               /* size of actual page */
	    char *free;           /* pointer to first free byte */
	    int bytes;            /* number of usable bytes in page */
	    int koff, ioff;       /* offset to add for kernel, interface addresses */
	  } *ffp;             /* first free page */

	  int sz;               /* num pages in heap */
	  int bytes;            /* num bytes free in current page */
	  int dyn;              /* boolean: allocate more pages? */
	  int camfd;            /* fd for device driver */
	} *hp;	   /* pointer to heap if buffer was allocate from one */

      } *usr_buf;

      struct buffer_struct {
	char *ptr;       /* ptr to the actual data */
	int sz, kersz;   /* size of usable buffer area, real size of buffer */
	int koff, ioff;  /* offsets to kernel and interace addresses */
	int camfd;       /* /dev/cam fd */

	struct heap_struct {
	  LL pglst;             /* list of pages */

	  struct page_struct {
	    /* pointers to the page in user, kernel and interface address space */
	    char *usr, *ker, *ifc;
	    int sz;               /* size of actual page */
	    char *free;           /* pointer to first free byte */
	    int bytes;            /* number of usable bytes in page */
	    int koff, ioff;       /* offset to add for kernel, interface addresses */
	  } *ffp;             /* first free page */

	  int sz;               /* num pages in heap */
	  int bytes;            /* num bytes free in current page */
	  int dyn;              /* boolean: allocate more pages? */
	  int camfd;            /* fd for device driver */
	} *hp;	   /* pointer to heap if buffer was allocate from one */

      } *def_buf;

      struct heap_struct {
	LL pglst;             /* list of pages */

	struct page_struct {
	  /* pointers to the page in user, kernel and interface address space */
	  char *usr, *ker, *ifc;
	  int sz;               /* size of actual page */
	  char *free;           /* pointer to first free byte */
	  int bytes;            /* number of usable bytes in page */
	  int koff, ioff;       /* offset to add for kernel, interface addresses */
	} *ffp;             /* first free page */

	int sz;               /* num pages in heap */
	int bytes;            /* num bytes free in current page */
	int dyn;              /* boolean: allocate more pages? */
	int camfd;            /* fd for device driver */
      } *hp;

      int regnum, buflen;
    } *save_instr;

    int save_regnum;

    struct buffer_struct {
      char *ptr;       /* ptr to the actual data */
      int sz, kersz;   /* size of usable buffer area, real size of buffer */
      int koff, ioff;  /* offsets to kernel and interace addresses */
      int camfd;       /* /dev/cam fd */

      struct heap_struct {
	LL pglst;             /* list of pages */

	struct page_struct {
	  /* pointers to the page in user, kernel and interface address space */
	  char *usr, *ker, *ifc;
	  int sz;               /* size of actual page */
	  char *free;           /* pointer to first free byte */
	  int bytes;            /* number of usable bytes in page */
	  int koff, ioff;       /* offset to add for kernel, interface addresses */
	} *ffp;             /* first free page */

	int sz;               /* num pages in heap */
	int bytes;            /* num bytes free in current page */
	int dyn;              /* boolean: allocate more pages? */
	int camfd;            /* fd for device driver */
      } *hp;	   /* pointer to heap if buffer was allocate from one */

    } *save_buf;

    int save_buflen;
  } *def;

  struct instr_struct {

    struct buffer_struct {
      char *ptr;       /* ptr to the actual data */
      int sz, kersz;   /* size of usable buffer area, real size of buffer */
      int koff, ioff;  /* offsets to kernel and interace addresses */
      int camfd;       /* /dev/cam fd */

      struct heap_struct {
	LL pglst;             /* list of pages */

	struct page_struct {
	  /* pointers to the page in user, kernel and interface address space */
	  char *usr, *ker, *ifc;
	  int sz;               /* size of actual page */
	  char *free;           /* pointer to first free byte */
	  int bytes;            /* number of usable bytes in page */
	  int koff, ioff;       /* offset to add for kernel, interface addresses */
	} *ffp;             /* first free page */

	int sz;               /* num pages in heap */
	int bytes;            /* num bytes free in current page */
	int dyn;              /* boolean: allocate more pages? */
	int camfd;            /* fd for device driver */
      } *hp;	   /* pointer to heap if buffer was allocate from one */

    } *sle;

    struct buffer_struct {
      char *ptr;       /* ptr to the actual data */
      int sz, kersz;   /* size of usable buffer area, real size of buffer */
      int koff, ioff;  /* offsets to kernel and interace addresses */
      int camfd;       /* /dev/cam fd */

      struct heap_struct {
	LL pglst;             /* list of pages */

	struct page_struct {
	  /* pointers to the page in user, kernel and interface address space */
	  char *usr, *ker, *ifc;
	  int sz;               /* size of actual page */
	  char *free;           /* pointer to first free byte */
	  int bytes;            /* number of usable bytes in page */
	  int koff, ioff;       /* offset to add for kernel, interface addresses */
	} *ffp;             /* first free page */

	int sz;               /* num pages in heap */
	int bytes;            /* num bytes free in current page */
	int dyn;              /* boolean: allocate more pages? */
	int camfd;            /* fd for device driver */
      } *hp;	   /* pointer to heap if buffer was allocate from one */

    } *usr_buf;

    struct buffer_struct {
      char *ptr;       /* ptr to the actual data */
      int sz, kersz;   /* size of usable buffer area, real size of buffer */
      int koff, ioff;  /* offsets to kernel and interace addresses */
      int camfd;       /* /dev/cam fd */

      struct heap_struct {
	LL pglst;             /* list of pages */

	struct page_struct {
	  /* pointers to the page in user, kernel and interface address space */
	  char *usr, *ker, *ifc;
	  int sz;               /* size of actual page */
	  char *free;           /* pointer to first free byte */
	  int bytes;            /* number of usable bytes in page */
	  int koff, ioff;       /* offset to add for kernel, interface addresses */
	} *ffp;             /* first free page */

	int sz;               /* num pages in heap */
	int bytes;            /* num bytes free in current page */
	int dyn;              /* boolean: allocate more pages? */
	int camfd;            /* fd for device driver */
      } *hp;	   /* pointer to heap if buffer was allocate from one */

    } *def_buf;

    struct heap_struct {
      LL pglst;             /* list of pages */

      struct page_struct {
	/* pointers to the page in user, kernel and interface address space */
	char *usr, *ker, *ifc;
	int sz;               /* size of actual page */
	char *free;           /* pointer to first free byte */
	int bytes;            /* number of usable bytes in page */
	int koff, ioff;       /* offset to add for kernel, interface addresses */
      } *ffp;             /* first free page */

      int sz;               /* num pages in heap */
      int bytes;            /* num bytes free in current page */
      int dyn;              /* boolean: allocate more pages? */
      int camfd;            /* fd for device driver */
    } *hp;

    int regnum, buflen;
  } *cir;

  struct cam_stream_struct {
    FILE *file;
    char *appname;
    int (*hook)();
    int lerr;
    MASK ops;
    unsigned char enable;
    unsigned char deadly;
    unsigned char verbose;
    unsigned char traceback;
    jmp_buf env;
  } *in;

  struct cam_stream_struct {
    FILE *file;
    char *appname;
    int (*hook)();
    int lerr;
    MASK ops;
    unsigned char enable;
    unsigned char deadly;
    unsigned char verbose;
    unsigned char traceback;
    jmp_buf env;
  } *out;
  
  struct cam_stream_struct {
    FILE *file;
    char *appname;
    int (*hook)();
    int lerr;
    MASK ops;
    unsigned char enable;
    unsigned char deadly;
    unsigned char verbose;
    unsigned char traceback;
    jmp_buf env;
  } *err;
  
  struct cam_stream_struct {
    FILE *file;
    char *appname;
    int (*hook)();
    int lerr;
    MASK ops;
    unsigned char enable;
    unsigned char deadly;
    unsigned char verbose;
    unsigned char traceback;
    jmp_buf env;
  } *dbug;

  int regnum;

  int camfd;

  int single_arg;

  int layer_mask;
};