pic18f458 header file problem

2010ee179 · Apr 2, 2012

Hey everyone, I just started to learn PIC18 micro controllers. I am following a book by mazidi.

Can you provide me pic18f458.h file which mazidi use???
It comes with Hi-Tech C compiler but there is some problem with it....I don't see any thing written in it nor in htc.h file. So compiler generates error that
undefined identifier..like when I write TMR0L etc.

Hope you understood....if didn't just give me pic18ff458.h file for Hi-tech Compiler.

bigdogguru · Apr 2, 2012

When using the Hi-Tech C Compilers, there is no need to include a device specific header file.

Simply include the htc.h header file as follows:

Code:

#include <htc.h>

It will select the appropriate header based on the device selected in the MPLAB IDE.

If you need to reference the device specific header while coding, simply add it to the project window.

For Example:

C:\Program Files\HI-TECH Software\PICC-18\PRO\9.66\include\pic18f458.h

pic18f458.h

Code:

#ifndef	_HTC_H_
#warning Header file pic18f458.h included directly. Use #include <htc.h> instead.
#endif

 /* header file for the MICROCHIP PIC microcontroller
    18F458
 */

#ifndef __PIC18F458_H
#define __PIC18F458_H

#include <peripheral/pconfig.h>

// Config Register: CONFIG1H
// Oscillator Selection bits
// RC oscillator w/ OSC2 configured as RA6
#define OSC_RCIO             0xFFFF 
// HS oscillator with PLL enabled/Clock frequency = (4 x FOSC)
#define OSC_HSPLL            0xFEFF 
// EC oscillator w/ OSC2 configured as RA6
#define OSC_ECIO             0xFDFF 
// EC oscillator w/ OSC2 configured as divide-by-4 clock output
#define OSC_EC               0xFCFF 
// RC oscillator
#define OSC_RC               0xFBFF 
// HS oscillator
#define OSC_HS               0xFAFF 
// XT oscillator
#define OSC_XT               0xF9FF 
// LP oscillator
#define OSC_LP               0xF8FF 
// Oscillator System Clock Switch Enable bit
// Oscillator system clock switch option is disabled (main oscillator is source)
#define OSCS_OFF             0xFFFF 
// Oscillator system clock switch option is enabled (oscillator switching is enabled)
#define OSCS_ON              0xDFFF 


// Config Register: CONFIG2L
// Power-up Timer Enable bit
// PWRT disabled
#define PWRT_OFF             0xFFFF 
// PWRT enabled
#define PWRT_ON              0xFFFE 
// Brown-out Reset Enable bit
// Brown-out Reset enabled
#define BOR_ON               0xFFFF 
// Brown-out Reset disabled
#define BOR_OFF              0xFFFD 
// Brown-out Reset Voltage bits
// VBOR set to 2.5V
#define BORV_25              0xFFFF 
// VBOR set to 2.7V
#define BORV_27              0xFFFB 
// VBOR set to 4.2V
#define BORV_42              0xFFF7 
// VBOR set to 4.5V
#define BORV_45              0xFFF3 


// Config Register: CONFIG2H
// Watchdog Timer Enable bit
// WDT enabled
#define WDT_ON               0xFFFF 
// WDT disabled (control is placed on the SWDTEN bit)
#define WDT_OFF              0xFEFF 
// Watchdog Timer Postscale Select bits
// 1:128
#define WDTPS_128            0xFFFF 
// 1:64
#define WDTPS_64             0xFDFF 
// 1:32
#define WDTPS_32             0xFBFF 
// 1:16
#define WDTPS_16             0xF9FF 
// 1:8
#define WDTPS_8              0xF7FF 
// 1:4
#define WDTPS_4              0xF5FF 
// 1:2
#define WDTPS_2              0xF3FF 
// 1:1
#define WDTPS_1              0xF1FF 


// Config Register: CONFIG4L
// Stack Full/Underflow Reset Enable bit
// Stack Full/Underflow will cause Reset
#define STVR_ON              0xFFFF 
// Stack Full/Underflow will not cause Reset
#define STVR_OFF             0xFFFE 
// Low-Voltage ICSP Enable bit
// Low-Voltage ICSP enabled
#define LVP_ON               0xFFFF 
// Low-Voltage ICSP disabled
#define LVP_OFF              0xFFFB 
// Background Debugger Enable bit
// Background Debugger disabled. RB6 and RB7 configured as general purpose I/O pins.
#define DEBUG_OFF            0xFFFF 
// Background Debugger enabled. RB6 and RB7 are dedicated to In-Circuit Debug.
#define DEBUG_ON             0xFF7F 


// Config Register: CONFIG5L
// Code Protection bit
// Block 0 (000200-001FFFh) not code protected
#define CP0_OFF              0xFFFF 
// Block 0 (000200-001FFFh) code protected
#define CP0_ON               0xFFFE 
// Code Protection bit
// Block 1 (002000-003FFFh) not code protected
#define CP1_OFF              0xFFFF 
// Block 1 (002000-003FFFh) code protected
#define CP1_ON               0xFFFD 
// Code Protection bit
// Block 2 (004000-005FFFh) not code protected
#define CP2_OFF              0xFFFF 
// Block 2 (004000-005FFFh) code protected
#define CP2_ON               0xFFFB 
// Code Protection bit
// Block 3 (006000-007FFFh) not code protected
#define CP3_OFF              0xFFFF 
// Block 3 (006000-007FFFh) code protected
#define CP3_ON               0xFFF7 


// Config Register: CONFIG5H
// Boot Block Code Protection bit
// Boot Block (000000-0001FFh) not code protected
#define CPB_OFF              0xFFFF 
// Boot Block (000000-0001FFh) code protected
#define CPB_ON               0xBFFF 
// Data EEPROM Code Protection bit
// Data EEPROM not code protected
#define CPD_OFF              0xFFFF 
// Data EEPROM code protected
#define CPD_ON               0x7FFF 


// Config Register: CONFIG6L
// Write Protection bit
// Block 0 (000200-001FFFh) not write protected
#define WRT0_OFF             0xFFFF 
// Block 0 (000200-001FFFh) write protected
#define WRT0_ON              0xFFFE 
// Write Protection bit
// Block 1 (002000-003FFFh) not write protected
#define WRT1_OFF             0xFFFF 
// Block 1 (002000-003FFFh) write protected
#define WRT1_ON              0xFFFD 
// Write Protection bit
// Block 2 (004000-005FFFh) not write protected
#define WRT2_OFF             0xFFFF 
// Block 2 (004000-005FFFh) write protected
#define WRT2_ON              0xFFFB 
// Write Protection bit
// Block 3 (006000-007FFFh) not write protected
#define WRT3_OFF             0xFFFF 
// Block 3 (006000-007FFFh) write protected
#define WRT3_ON              0xFFF7 


// Config Register: CONFIG6H
// Configuration Register Write Protection bit
// Configuration registers (300000-3000FFh) not write protected
#define WRTC_OFF             0xFFFF 
// Configuration registers (300000-3000FFh) write protected
#define WRTC_ON              0xDFFF 
// Boot Block Write Protection bit
// Boot Block (000000-0001FFh) not write protected
#define WRTB_OFF             0xFFFF 
// Boot Block (000000-0001FFh) write protected
#define WRTB_ON              0xBFFF 
// Data EEPROM Write Protection bit
// Data EEPROM not write protected
#define WRTD_OFF             0xFFFF 
// Data EEPROM write protected
#define WRTD_ON              0x7FFF 


// Config Register: CONFIG7L
// Table Read Protection bit
// Block 0 (000200-001FFFh) not protected from Table Reads executed in other blocks
#define EBTR0_OFF            0xFFFF 
// Block 0 (000200-001FFFh) protected from Table Reads executed in other blocks
#define EBTR0_ON             0xFFFE 
// Table Read Protection bit
// Block 1 (002000-003FFFh) not protected from Table Reads executed in other blocks
#define EBTR1_OFF            0xFFFF 
// Block 1 (002000-003FFFh) protected from Table Reads executed in other blocks
#define EBTR1_ON             0xFFFD 
// Table Read Protection bit
// Block 2 (004000-005FFFh) not protected from Table Reads executed in other blocks
#define EBTR2_OFF            0xFFFF 
// Block 2 (004000-005FFFh) protected from Table Reads executed in other blocks
#define EBTR2_ON             0xFFFB 
// Table Read Protection bit
// Block 3 (006000-007FFFh) not protected from Table Reads executed in other blocks
#define EBTR3_OFF            0xFFFF 
// Block 3 (006000-007FFFh) protected from Table Reads executed in other blocks
#define EBTR3_ON             0xFFF7 


// Config Register: CONFIG7H
// Boot Block Table Read Protection bit
// Boot Block (000000-0001FFh) not protected from Table Reads executed in other blocks
#define EBTRB_OFF            0xFFFF 
// Boot Block (000000-0001FFh) protected from Table Reads executed in other blocks
#define EBTRB_ON             0xBFFF 


//
// Special function register definitions: Bank 0xf
//

// Register: RXF0SIDH
extern volatile unsigned char           RXF0SIDH            @ 0xF00;
// bit and bitfield definitions
//extern volatile bit SID3               @ ((unsigned)&RXF0SIDH*8)+0;
//extern volatile bit SID4               @ ((unsigned)&RXF0SIDH*8)+1;
//extern volatile bit SID5               @ ((unsigned)&RXF0SIDH*8)+2;
//extern volatile bit SID6               @ ((unsigned)&RXF0SIDH*8)+3;
//extern volatile bit SID7               @ ((unsigned)&RXF0SIDH*8)+4;
//extern volatile bit SID8               @ ((unsigned)&RXF0SIDH*8)+5;
//extern volatile bit SID9               @ ((unsigned)&RXF0SIDH*8)+6;
//extern volatile bit SID10              @ ((unsigned)&RXF0SIDH*8)+7;
extern union {
    struct {
        volatile unsigned SID3                : 1;
        volatile unsigned SID4                : 1;
        volatile unsigned SID5                : 1;
        volatile unsigned SID6                : 1;
        volatile unsigned SID7                : 1;
        volatile unsigned SID8                : 1;
        volatile unsigned SID9                : 1;
        volatile unsigned SID10               : 1;
    };
} RXF0SIDHbits @ 0xF00;

// Register: RXF0SIDL
extern volatile unsigned char           RXF0SIDL            @ 0xF01;
// bit and bitfield definitions
//extern volatile bit EID16              @ ((unsigned)&RXF0SIDL*8)+0;
//extern volatile bit EID17              @ ((unsigned)&RXF0SIDL*8)+1;
//extern volatile bit EXIDEN             @ ((unsigned)&RXF0SIDL*8)+3;
//extern volatile bit SID0               @ ((unsigned)&RXF0SIDL*8)+5;
//extern volatile bit SID1               @ ((unsigned)&RXF0SIDL*8)+6;
//extern volatile bit SID2               @ ((unsigned)&RXF0SIDL*8)+7;
extern union {
    struct {
        volatile unsigned EID16               : 1;
        volatile unsigned EID17               : 1;
        volatile unsigned                     : 1;
        volatile unsigned EXIDEN              : 1;
        volatile unsigned : 1;
        volatile unsigned SID0                : 1;
        volatile unsigned SID1                : 1;
        volatile unsigned SID2                : 1;
    };
} RXF0SIDLbits @ 0xF01;

// Register: RXF0EIDH
extern volatile unsigned char           RXF0EIDH            @ 0xF02;
// bit and bitfield definitions
//extern volatile bit EID8               @ ((unsigned)&RXF0EIDH*8)+0;
//extern volatile bit EID9               @ ((unsigned)&RXF0EIDH*8)+1;
//extern volatile bit EID10              @ ((unsigned)&RXF0EIDH*8)+2;
//extern volatile bit EID11              @ ((unsigned)&RXF0EIDH*8)+3;
//extern volatile bit EID12              @ ((unsigned)&RXF0EIDH*8)+4;
//extern volatile bit EID13              @ ((unsigned)&RXF0EIDH*8)+5;
//extern volatile bit EID14              @ ((unsigned)&RXF0EIDH*8)+6;
//extern volatile bit EID15              @ ((unsigned)&RXF0EIDH*8)+7;
extern union {
    struct {
        volatile unsigned EID8                : 1;
        volatile unsigned EID9                : 1;
        volatile unsigned EID10               : 1;
        volatile unsigned EID11               : 1;
        volatile unsigned EID12               : 1;
        volatile unsigned EID13               : 1;
        volatile unsigned EID14               : 1;
        volatile unsigned EID15               : 1;
    };
} RXF0EIDHbits @ 0xF02;

// Register: RXF0EIDL
extern volatile unsigned char           RXF0EIDL            @ 0xF03;
// bit and bitfield definitions
//extern volatile bit EID0               @ ((unsigned)&RXF0EIDL*8)+0;
//extern volatile bit EID1               @ ((unsigned)&RXF0EIDL*8)+1;
//extern volatile bit EID2               @ ((unsigned)&RXF0EIDL*8)+2;
//extern volatile bit EID3               @ ((unsigned)&RXF0EIDL*8)+3;
//extern volatile bit EID4               @ ((unsigned)&RXF0EIDL*8)+4;
//extern volatile bit EID5               @ ((unsigned)&RXF0EIDL*8)+5;
//extern volatile bit EID6               @ ((unsigned)&RXF0EIDL*8)+6;
//extern volatile bit EID7               @ ((unsigned)&RXF0EIDL*8)+7;
extern union {
    struct {
        volatile unsigned EID0                : 1;
        volatile unsigned EID1                : 1;
        volatile unsigned EID2                : 1;
        volatile unsigned EID3                : 1;
        volatile unsigned EID4                : 1;
        volatile unsigned EID5                : 1;
        volatile unsigned EID6                : 1;
        volatile unsigned EID7                : 1;
    };
} RXF0EIDLbits @ 0xF03;

// Register: RXF1SIDH
extern volatile unsigned char           RXF1SIDH            @ 0xF04;
// bit and bitfield definitions
//extern volatile bit SID3               @ ((unsigned)&RXF1SIDH*8)+0;
//extern volatile bit SID4               @ ((unsigned)&RXF1SIDH*8)+1;
//extern volatile bit SID5               @ ((unsigned)&RXF1SIDH*8)+2;
//extern volatile bit SID6               @ ((unsigned)&RXF1SIDH*8)+3;
//extern volatile bit SID7               @ ((unsigned)&RXF1SIDH*8)+4;
//extern volatile bit SID8               @ ((unsigned)&RXF1SIDH*8)+5;
//extern volatile bit SID9               @ ((unsigned)&RXF1SIDH*8)+6;
//extern volatile bit SID10              @ ((unsigned)&RXF1SIDH*8)+7;
extern union {
    struct {
        volatile unsigned SID3                : 1;
        volatile unsigned SID4                : 1;
        volatile unsigned SID5                : 1;
        volatile unsigned SID6                : 1;
        volatile unsigned SID7                : 1;
        volatile unsigned SID8                : 1;
        volatile unsigned SID9                : 1;
        volatile unsigned SID10               : 1;
    };
} RXF1SIDHbits @ 0xF04;

// Register: RXF1SIDL
extern volatile unsigned char           RXF1SIDL            @ 0xF05;
// bit and bitfield definitions
//extern volatile bit EID16              @ ((unsigned)&RXF1SIDL*8)+0;
//extern volatile bit EID17              @ ((unsigned)&RXF1SIDL*8)+1;
//extern volatile bit EXIDEN             @ ((unsigned)&RXF1SIDL*8)+3;
//extern volatile bit SID0               @ ((unsigned)&RXF1SIDL*8)+5;
//extern volatile bit SID1               @ ((unsigned)&RXF1SIDL*8)+6;
//extern volatile bit SID2               @ ((unsigned)&RXF1SIDL*8)+7;
extern union {
    struct {
        volatile unsigned EID16               : 1;
        volatile unsigned EID17               : 1;
        volatile unsigned                     : 1;
        volatile unsigned EXIDEN              : 1;
        volatile unsigned : 1;
        volatile unsigned SID0                : 1;
        volatile unsigned SID1                : 1;
        volatile unsigned SID2                : 1;
    };
} RXF1SIDLbits @ 0xF05;

// Register: RXF1EIDH
extern volatile unsigned char           RXF1EIDH            @ 0xF06;
// bit and bitfield definitions
//extern volatile bit EID8               @ ((unsigned)&RXF1EIDH*8)+0;
//extern volatile bit EID9               @ ((unsigned)&RXF1EIDH*8)+1;
//extern volatile bit EID10              @ ((unsigned)&RXF1EIDH*8)+2;
//extern volatile bit EID11              @ ((unsigned)&RXF1EIDH*8)+3;
//extern volatile bit EID12              @ ((unsigned)&RXF1EIDH*8)+4;
//extern volatile bit EID13              @ ((unsigned)&RXF1EIDH*8)+5;
//extern volatile bit EID14              @ ((unsigned)&RXF1EIDH*8)+6;
//extern volatile bit EID15              @ ((unsigned)&RXF1EIDH*8)+7;
extern union {
    struct {
        volatile unsigned EID8                : 1;
        volatile unsigned EID9                : 1;
        volatile unsigned EID10               : 1;
        volatile unsigned EID11               : 1;
        volatile unsigned EID12               : 1;
        volatile unsigned EID13               : 1;
        volatile unsigned EID14               : 1;
        volatile unsigned EID15               : 1;
    };
} RXF1EIDHbits @ 0xF06;

// Register: RXF1EIDL
extern volatile unsigned char           RXF1EIDL            @ 0xF07;
// bit and bitfield definitions
//extern volatile bit EID0               @ ((unsigned)&RXF1EIDL*8)+0;
//extern volatile bit EID1               @ ((unsigned)&RXF1EIDL*8)+1;
//extern volatile bit EID2               @ ((unsigned)&RXF1EIDL*8)+2;
//extern volatile bit EID3               @ ((unsigned)&RXF1EIDL*8)+3;
//extern volatile bit EID4               @ ((unsigned)&RXF1EIDL*8)+4;
//extern volatile bit EID5               @ ((unsigned)&RXF1EIDL*8)+5;
//extern volatile bit EID6               @ ((unsigned)&RXF1EIDL*8)+6;
//extern volatile bit EID7               @ ((unsigned)&RXF1EIDL*8)+7;
extern union {
    struct {
        volatile unsigned EID0                : 1;
        volatile unsigned EID1                : 1;
        volatile unsigned EID2                : 1;
        volatile unsigned EID3                : 1;
        volatile unsigned EID4                : 1;
        volatile unsigned EID5                : 1;
        volatile unsigned EID6                : 1;
        volatile unsigned EID7                : 1;
    };
} RXF1EIDLbits @ 0xF07;

// Register: RXF2SIDH
extern volatile unsigned char           RXF2SIDH            @ 0xF08;
// bit and bitfield definitions
//extern volatile bit SID3               @ ((unsigned)&RXF2SIDH*8)+0;
//extern volatile bit SID4               @ ((unsigned)&RXF2SIDH*8)+1;
//extern volatile bit SID5               @ ((unsigned)&RXF2SIDH*8)+2;
//extern volatile bit SID6               @ ((unsigned)&RXF2SIDH*8)+3;
//extern volatile bit SID7               @ ((unsigned)&RXF2SIDH*8)+4;
//extern volatile bit SID8               @ ((unsigned)&RXF2SIDH*8)+5;
//extern volatile bit SID9               @ ((unsigned)&RXF2SIDH*8)+6;
//extern volatile bit SID10              @ ((unsigned)&RXF2SIDH*8)+7;
extern union {
    struct {
        volatile unsigned SID3                : 1;
        volatile unsigned SID4                : 1;
        volatile unsigned SID5                : 1;
        volatile unsigned SID6                : 1;
        volatile unsigned SID7                : 1;
        volatile unsigned SID8                : 1;
        volatile unsigned SID9                : 1;
        volatile unsigned SID10               : 1;
    };
} RXF2SIDHbits @ 0xF08;

// Register: RXF2SIDL
extern volatile unsigned char           RXF2SIDL            @ 0xF09;
// bit and bitfield definitions
//extern volatile bit EID16              @ ((unsigned)&RXF2SIDL*8)+0;
//extern volatile bit EID17              @ ((unsigned)&RXF2SIDL*8)+1;
//extern volatile bit EXIDEN             @ ((unsigned)&RXF2SIDL*8)+3;
//extern volatile bit SID0               @ ((unsigned)&RXF2SIDL*8)+5;
//extern volatile bit SID1               @ ((unsigned)&RXF2SIDL*8)+6;
//extern volatile bit SID2               @ ((unsigned)&RXF2SIDL*8)+7;
extern union {
    struct {
        volatile unsigned EID16               : 1;
        volatile unsigned EID17               : 1;
        volatile unsigned                     : 1;
        volatile unsigned EXIDEN              : 1;
        volatile unsigned : 1;
        volatile unsigned SID0                : 1;
        volatile unsigned SID1                : 1;
        volatile unsigned SID2                : 1;
    };
} RXF2SIDLbits @ 0xF09;

// Register: RXF2EIDH
extern volatile unsigned char           RXF2EIDH            @ 0xF0A;
// bit and bitfield definitions
//extern volatile bit EID8               @ ((unsigned)&RXF2EIDH*8)+0;
//extern volatile bit EID9               @ ((unsigned)&RXF2EIDH*8)+1;
//extern volatile bit EID10              @ ((unsigned)&RXF2EIDH*8)+2;
//extern volatile bit EID11              @ ((unsigned)&RXF2EIDH*8)+3;
//extern volatile bit EID12              @ ((unsigned)&RXF2EIDH*8)+4;
//extern volatile bit EID13              @ ((unsigned)&RXF2EIDH*8)+5;
//extern volatile bit EID14              @ ((unsigned)&RXF2EIDH*8)+6;
//extern volatile bit EID15              @ ((unsigned)&RXF2EIDH*8)+7;
extern union {
    struct {
        volatile unsigned EID8                : 1;
        volatile unsigned EID9                : 1;
        volatile unsigned EID10               : 1;
        volatile unsigned EID11               : 1;
        volatile unsigned EID12               : 1;
        volatile unsigned EID13               : 1;
        volatile unsigned EID14               : 1;
        volatile unsigned EID15               : 1;
    };
} RXF2EIDHbits @ 0xF0A;

// Register: RXF2EIDL
extern volatile unsigned char           RXF2EIDL            @ 0xF0B;
// bit and bitfield definitions
//extern volatile bit EID0               @ ((unsigned)&RXF2EIDL*8)+0;
//extern volatile bit EID1               @ ((unsigned)&RXF2EIDL*8)+1;
//extern volatile bit EID2               @ ((unsigned)&RXF2EIDL*8)+2;
//extern volatile bit EID3               @ ((unsigned)&RXF2EIDL*8)+3;
//extern volatile bit EID4               @ ((unsigned)&RXF2EIDL*8)+4;
//extern volatile bit EID5               @ ((unsigned)&RXF2EIDL*8)+5;
//extern volatile bit EID6               @ ((unsigned)&RXF2EIDL*8)+6;
//extern volatile bit EID7               @ ((unsigned)&RXF2EIDL*8)+7;
extern union {
    struct {
        volatile unsigned EID0                : 1;
        volatile unsigned EID1                : 1;
        volatile unsigned EID2                : 1;
        volatile unsigned EID3                : 1;
        volatile unsigned EID4                : 1;
        volatile unsigned EID5                : 1;
        volatile unsigned EID6                : 1;
        volatile unsigned EID7                : 1;
    };
} RXF2EIDLbits @ 0xF0B;

// Register: RXF3SIDH
extern volatile unsigned char           RXF3SIDH            @ 0xF0C;
// bit and bitfield definitions
//extern volatile bit SID3               @ ((unsigned)&RXF3SIDH*8)+0;
//extern volatile bit SID4               @ ((unsigned)&RXF3SIDH*8)+1;
//extern volatile bit SID5               @ ((unsigned)&RXF3SIDH*8)+2;
//extern volatile bit SID6               @ ((unsigned)&RXF3SIDH*8)+3;
//extern volatile bit SID7               @ ((unsigned)&RXF3SIDH*8)+4;
//extern volatile bit SID8               @ ((unsigned)&RXF3SIDH*8)+5;
//extern volatile bit SID9               @ ((unsigned)&RXF3SIDH*8)+6;
//extern volatile bit SID10              @ ((unsigned)&RXF3SIDH*8)+7;
extern union {
    struct {
        volatile unsigned SID3                : 1;
        volatile unsigned SID4                : 1;
        volatile unsigned SID5                : 1;
        volatile unsigned SID6                : 1;
        volatile unsigned SID7                : 1;
        volatile unsigned SID8                : 1;
        volatile unsigned SID9                : 1;
        volatile unsigned SID10               : 1;
    };
} RXF3SIDHbits @ 0xF0C;

// Register: RXF3SIDL
extern volatile unsigned char           RXF3SIDL            @ 0xF0D;
// bit and bitfield definitions
//extern volatile bit EID16              @ ((unsigned)&RXF3SIDL*8)+0;
//extern volatile bit EID17              @ ((unsigned)&RXF3SIDL*8)+1;
//extern volatile bit EXIDEN             @ ((unsigned)&RXF3SIDL*8)+3;
//extern volatile bit SID0               @ ((unsigned)&RXF3SIDL*8)+5;
//extern volatile bit SID1               @ ((unsigned)&RXF3SIDL*8)+6;
//extern volatile bit SID2               @ ((unsigned)&RXF3SIDL*8)+7;
extern union {
    struct {
        volatile unsigned EID16               : 1;
        volatile unsigned EID17               : 1;
        volatile unsigned                     : 1;
        volatile unsigned EXIDEN              : 1;
        volatile unsigned : 1;
        volatile unsigned SID0                : 1;
        volatile unsigned SID1                : 1;
        volatile unsigned SID2                : 1;
    };
} RXF3SIDLbits @ 0xF0D;

// Register: RXF3EIDH
extern volatile unsigned char           RXF3EIDH            @ 0xF0E;
// bit and bitfield definitions
//extern volatile bit EID8               @ ((unsigned)&RXF3EIDH*8)+0;
//extern volatile bit EID9               @ ((unsigned)&RXF3EIDH*8)+1;
//extern volatile bit EID10              @ ((unsigned)&RXF3EIDH*8)+2;
//extern volatile bit EID11              @ ((unsigned)&RXF3EIDH*8)+3;
//extern volatile bit EID12              @ ((unsigned)&RXF3EIDH*8)+4;
//extern volatile bit EID13              @ ((unsigned)&RXF3EIDH*8)+5;
//extern volatile bit EID14              @ ((unsigned)&RXF3EIDH*8)+6;
//extern volatile bit EID15              @ ((unsigned)&RXF3EIDH*8)+7;
extern union {
    struct {
        volatile unsigned EID8                : 1;
        volatile unsigned EID9                : 1;
        volatile unsigned EID10               : 1;
        volatile unsigned EID11               : 1;
        volatile unsigned EID12               : 1;
        volatile unsigned EID13               : 1;
        volatile unsigned EID14               : 1;
        volatile unsigned EID15               : 1;
    };
} RXF3EIDHbits @ 0xF0E;

// Register: RXF3EIDL
extern volatile unsigned char           RXF3EIDL            @ 0xF0F;
// bit and bitfield definitions
//extern volatile bit EID0               @ ((unsigned)&RXF3EIDL*8)+0;
//extern volatile bit EID1               @ ((unsigned)&RXF3EIDL*8)+1;
//extern volatile bit EID2               @ ((unsigned)&RXF3EIDL*8)+2;
//extern volatile bit EID3               @ ((unsigned)&RXF3EIDL*8)+3;
//extern volatile bit EID4               @ ((unsigned)&RXF3EIDL*8)+4;
//extern volatile bit EID5               @ ((unsigned)&RXF3EIDL*8)+5;
//extern volatile bit EID6               @ ((unsigned)&RXF3EIDL*8)+6;
//extern volatile bit EID7               @ ((unsigned)&RXF3EIDL*8)+7;
extern union {
    struct {
        volatile unsigned EID0                : 1;
        volatile unsigned EID1                : 1;
        volatile unsigned EID2                : 1;
        volatile unsigned EID3                : 1;
        volatile unsigned EID4                : 1;
        volatile unsigned EID5                : 1;
        volatile unsigned EID6                : 1;
        volatile unsigned EID7                : 1;
    };
} RXF3EIDLbits @ 0xF0F;

// Register: RXF4SIDH
extern volatile unsigned char           RXF4SIDH            @ 0xF10;
// bit and bitfield definitions
//extern volatile bit SID3               @ ((unsigned)&RXF4SIDH*8)+0;
//extern volatile bit SID4               @ ((unsigned)&RXF4SIDH*8)+1;
//extern volatile bit SID5               @ ((unsigned)&RXF4SIDH*8)+2;
//extern volatile bit SID6               @ ((unsigned)&RXF4SIDH*8)+3;
//extern volatile bit SID7               @ ((unsigned)&RXF4SIDH*8)+4;
//extern volatile bit SID8               @ ((unsigned)&RXF4SIDH*8)+5;
//extern volatile bit SID9               @ ((unsigned)&RXF4SIDH*8)+6;
//extern volatile bit SID10              @ ((unsigned)&RXF4SIDH*8)+7;
extern union {
    struct {
        volatile unsigned SID3                : 1;
        volatile unsigned SID4                : 1;
        volatile unsigned SID5                : 1;
        volatile unsigned SID6                : 1;
        volatile unsigned SID7                : 1;
        volatile unsigned SID8                : 1;
        volatile unsigned SID9                : 1;
        volatile unsigned SID10               : 1;
    };
} RXF4SIDHbits @ 0xF10;

// Register: RXF4SIDL
extern volatile unsigned char           RXF4SIDL            @ 0xF11;
// bit and bitfield definitions
//extern volatile bit EID16              @ ((unsigned)&RXF4SIDL*8)+0;
//extern volatile bit EID17              @ ((unsigned)&RXF4SIDL*8)+1;
//extern volatile bit EXIDEN             @ ((unsigned)&RXF4SIDL*8)+3;
//extern volatile bit SID0               @ ((unsigned)&RXF4SIDL*8)+5;
//extern volatile bit SID1               @ ((unsigned)&RXF4SIDL*8)+6;
//extern volatile bit SID2               @ ((unsigned)&RXF4SIDL*8)+7;
extern union {
    struct {
        volatile unsigned EID16               : 1;
        volatile unsigned EID17               : 1;
        volatile unsigned                     : 1;
        volatile unsigned EXIDEN              : 1;
        volatile unsigned : 1;
        volatile unsigned SID0                : 1;
        volatile unsigned SID1                : 1;
        volatile unsigned SID2                : 1;
    };
} RXF4SIDLbits @ 0xF11;

// Register: RXF4EIDH
extern volatile unsigned char           RXF4EIDH            @ 0xF12;
// bit and bitfield definitions
//extern volatile bit EID8               @ ((unsigned)&RXF4EIDH*8)+0;
//extern volatile bit EID9               @ ((unsigned)&RXF4EIDH*8)+1;
//extern volatile bit EID10              @ ((unsigned)&RXF4EIDH*8)+2;
//extern volatile bit EID11              @ ((unsigned)&RXF4EIDH*8)+3;
//extern volatile bit EID12              @ ((unsigned)&RXF4EIDH*8)+4;
//extern volatile bit EID13              @ ((unsigned)&RXF4EIDH*8)+5;
//extern volatile bit EID14              @ ((unsigned)&RXF4EIDH*8)+6;
//extern volatile bit EID15              @ ((unsigned)&RXF4EIDH*8)+7;
extern union {
    struct {
        volatile unsigned EID8                : 1;
        volatile unsigned EID9                : 1;
        volatile unsigned EID10               : 1;
        volatile unsigned EID11               : 1;
        volatile unsigned EID12               : 1;
        volatile unsigned EID13               : 1;
        volatile unsigned EID14               : 1;
        volatile unsigned EID15               : 1;
    };
} RXF4EIDHbits @ 0xF12;

// Register: RXF4EIDL
extern volatile unsigned char           RXF4EIDL            @ 0xF13;
// bit and bitfield definitions
//extern volatile bit EID0               @ ((unsigned)&RXF4EIDL*8)+0;
//extern volatile bit EID1               @ ((unsigned)&RXF4EIDL*8)+1;
//extern volatile bit EID2               @ ((unsigned)&RXF4EIDL*8)+2;
//extern volatile bit EID3               @ ((unsigned)&RXF4EIDL*8)+3;
//extern volatile bit EID4               @ ((unsigned)&RXF4EIDL*8)+4;
//extern volatile bit EID5               @ ((unsigned)&RXF4EIDL*8)+5;
//extern volatile bit EID6               @ ((unsigned)&RXF4EIDL*8)+6;
//extern volatile bit EID7               @ ((unsigned)&RXF4EIDL*8)+7;
extern union {
    struct {
        volatile unsigned EID0                : 1;
        volatile unsigned EID1                : 1;
        volatile unsigned EID2                : 1;
        volatile unsigned EID3                : 1;
        volatile unsigned EID4                : 1;
        volatile unsigned EID5                : 1;
        volatile unsigned EID6                : 1;
        volatile unsigned EID7                : 1;
    };
} RXF4EIDLbits @ 0xF13;

// Register: RXF5SIDH
extern volatile unsigned char           RXF5SIDH            @ 0xF14;
// bit and bitfield definitions
//extern volatile bit SID3               @ ((unsigned)&RXF5SIDH*8)+0;
//extern volatile bit SID4               @ ((unsigned)&RXF5SIDH*8)+1;
//extern volatile bit SID5               @ ((unsigned)&RXF5SIDH*8)+2;
//extern volatile bit SID6               @ ((unsigned)&RXF5SIDH*8)+3;
//extern volatile bit SID7               @ ((unsigned)&RXF5SIDH*8)+4;
//extern volatile bit SID8               @ ((unsigned)&RXF5SIDH*8)+5;
//extern volatile bit SID9               @ ((unsigned)&RXF5SIDH*8)+6;
//extern volatile bit SID10              @ ((unsigned)&RXF5SIDH*8)+7;
extern union {
    struct {
        volatile unsigned SID3                : 1;
        volatile unsigned SID4                : 1;
        volatile unsigned SID5                : 1;
        volatile unsigned SID6                : 1;
        volatile unsigned SID7                : 1;
        volatile unsigned SID8                : 1;
        volatile unsigned SID9                : 1;
        volatile unsigned SID10               : 1;
    };
} RXF5SIDHbits @ 0xF14;

// Register: RXF5SIDL
extern volatile unsigned char           RXF5SIDL            @ 0xF15;
// bit and bitfield definitions
//extern volatile bit EID16              @ ((unsigned)&RXF5SIDL*8)+0;
//extern volatile bit EID17              @ ((unsigned)&RXF5SIDL*8)+1;
//extern volatile bit EXIDEN             @ ((unsigned)&RXF5SIDL*8)+3;
//extern volatile bit SID0               @ ((unsigned)&RXF5SIDL*8)+5;
//extern volatile bit SID1               @ ((unsigned)&RXF5SIDL*8)+6;
//extern volatile bit SID2               @ ((unsigned)&RXF5SIDL*8)+7;
extern union {
    struct {
        volatile unsigned EID16               : 1;
        volatile unsigned EID17               : 1;
        volatile unsigned                     : 1;
        volatile unsigned EXIDEN              : 1;
        volatile unsigned : 1;
        volatile unsigned SID0                : 1;
        volatile unsigned SID1                : 1;
        volatile unsigned SID2                : 1;
    };
} RXF5SIDLbits @ 0xF15;

// Register: RXF5EIDH
extern volatile unsigned char           RXF5EIDH            @ 0xF16;
// bit and bitfield definitions
//extern volatile bit EID8               @ ((unsigned)&RXF5EIDH*8)+0;
//extern volatile bit EID9               @ ((unsigned)&RXF5EIDH*8)+1;
//extern volatile bit EID10              @ ((unsigned)&RXF5EIDH*8)+2;
//extern volatile bit EID11              @ ((unsigned)&RXF5EIDH*8)+3;
//extern volatile bit EID12              @ ((unsigned)&RXF5EIDH*8)+4;
//extern volatile bit EID13              @ ((unsigned)&RXF5EIDH*8)+5;
//extern volatile bit EID14              @ ((unsigned)&RXF5EIDH*8)+6;
//extern volatile bit EID15              @ ((unsigned)&RXF5EIDH*8)+7;
extern union {
    struct {
        volatile unsigned EID8                : 1;
        volatile unsigned EID9                : 1;
        volatile unsigned EID10               : 1;
        volatile unsigned EID11               : 1;
        volatile unsigned EID12               : 1;
        volatile unsigned EID13               : 1;
        volatile unsigned EID14               : 1;
        volatile unsigned EID15               : 1;
    };
} RXF5EIDHbits @ 0xF16;

// Register: RXF5EIDL
extern volatile unsigned char           RXF5EIDL            @ 0xF17;
// bit and bitfield definitions
//extern volatile bit EID0               @ ((unsigned)&RXF5EIDL*8)+0;
//extern volatile bit EID1               @ ((unsigned)&RXF5EIDL*8)+1;
//extern volatile bit EID2               @ ((unsigned)&RXF5EIDL*8)+2;
//extern volatile bit EID3               @ ((unsigned)&RXF5EIDL*8)+3;
//extern volatile bit EID4               @ ((unsigned)&RXF5EIDL*8)+4;
//extern volatile bit EID5               @ ((unsigned)&RXF5EIDL*8)+5;
//extern volatile bit EID6               @ ((unsigned)&RXF5EIDL*8)+6;
//extern volatile bit EID7               @ ((unsigned)&RXF5EIDL*8)+7;
extern union {
    struct {
        volatile unsigned EID0                : 1;
        volatile unsigned EID1                : 1;
        volatile unsigned EID2                : 1;
        volatile unsigned EID3                : 1;
        volatile unsigned EID4                : 1;
        volatile unsigned EID5                : 1;
        volatile unsigned EID6                : 1;
        volatile unsigned EID7                : 1;
    };
} RXF5EIDLbits @ 0xF17;

// Register: RXM0SIDH
extern volatile unsigned char           RXM0SIDH            @ 0xF18;
// bit and bitfield definitions
//extern volatile bit SID3               @ ((unsigned)&RXM0SIDH*8)+0;
//extern volatile bit SID4               @ ((unsigned)&RXM0SIDH*8)+1;
//extern volatile bit SID5               @ ((unsigned)&RXM0SIDH*8)+2;
//extern volatile bit SID6               @ ((unsigned)&RXM0SIDH*8)+3;
//extern volatile bit SID7               @ ((unsigned)&RXM0SIDH*8)+4;
//extern volatile bit SID8               @ ((unsigned)&RXM0SIDH*8)+5;
//extern volatile bit SID9               @ ((unsigned)&RXM0SIDH*8)+6;
//extern volatile bit SID10              @ ((unsigned)&RXM0SIDH*8)+7;
extern union {
    struct {
        volatile unsigned SID3                : 1;
        volatile unsigned SID4                : 1;
        volatile unsigned SID5                : 1;
        volatile unsigned SID6                : 1;
        volatile unsigned SID7                : 1;
        volatile unsigned SID8                : 1;
        volatile unsigned SID9                : 1;
        volatile unsigned SID10               : 1;
    };
} RXM0SIDHbits @ 0xF18;

// Register: RXM0SIDL
extern volatile unsigned char           RXM0SIDL            @ 0xF19;
// bit and bitfield definitions
//extern volatile bit EID16              @ ((unsigned)&RXM0SIDL*8)+0;
//extern volatile bit EID17              @ ((unsigned)&RXM0SIDL*8)+1;
//extern volatile bit SID0               @ ((unsigned)&RXM0SIDL*8)+5;
//extern volatile bit SID1               @ ((unsigned)&RXM0SIDL*8)+6;
//extern volatile bit SID2               @ ((unsigned)&RXM0SIDL*8)+7;
extern union {
    struct {
        volatile unsigned EID16               : 1;
        volatile unsigned EID17               : 1;
        volatile unsigned                     : 3;
        volatile unsigned SID0                : 1;
        volatile unsigned SID1                : 1;
        volatile unsigned SID2                : 1;
    };
} RXM0SIDLbits @ 0xF19;

// Register: RXM0EIDH
extern volatile unsigned char           RXM0EIDH            @ 0xF1A;
// bit and bitfield definitions
//extern volatile bit EID8               @ ((unsigned)&RXM0EIDH*8)+0;
//extern volatile bit EID9               @ ((unsigned)&RXM0EIDH*8)+1;
//extern volatile bit EID10              @ ((unsigned)&RXM0EIDH*8)+2;
//extern volatile bit EID11              @ ((unsigned)&RXM0EIDH*8)+3;
//extern volatile bit EID12              @ ((unsigned)&RXM0EIDH*8)+4;
//extern volatile bit EID13              @ ((unsigned)&RXM0EIDH*8)+5;
//extern volatile bit EID14              @ ((unsigned)&RXM0EIDH*8)+6;
//extern volatile bit EID15              @ ((unsigned)&RXM0EIDH*8)+7;
extern union {
    struct {
        volatile unsigned EID8                : 1;
        volatile unsigned EID9                : 1;
        volatile unsigned EID10               : 1;
        volatile unsigned EID11               : 1;
        volatile unsigned EID12               : 1;
        volatile unsigned EID13               : 1;
        volatile unsigned EID14               : 1;
        volatile unsigned EID15               : 1;
    };
} RXM0EIDHbits @ 0xF1A;

// Register: RXM0EIDL
extern volatile unsigned char           RXM0EIDL            @ 0xF1B;
// bit and bitfield definitions
//extern volatile bit EID0               @ ((unsigned)&RXM0EIDL*8)+0;
//extern volatile bit EID1               @ ((unsigned)&RXM0EIDL*8)+1;
//extern volatile bit EID2               @ ((unsigned)&RXM0EIDL*8)+2;
//extern volatile bit EID3               @ ((unsigned)&RXM0EIDL*8)+3;
//extern volatile bit EID4               @ ((unsigned)&RXM0EIDL*8)+4;
//extern volatile bit EID5               @ ((unsigned)&RXM0EIDL*8)+5;
//extern volatile bit EID6               @ ((unsigned)&RXM0EIDL*8)+6;
//extern volatile bit EID7               @ ((unsigned)&RXM0EIDL*8)+7;
extern union {
    struct {
        volatile unsigned EID0                : 1;
        volatile unsigned EID1                : 1;
        volatile unsigned EID2                : 1;
        volatile unsigned EID3                : 1;
        volatile unsigned EID4                : 1;
        volatile unsigned EID5                : 1;
        volatile unsigned EID6                : 1;
        volatile unsigned EID7                : 1;
    };
} RXM0EIDLbits @ 0xF1B;

// Register: RXM1SIDH
extern volatile unsigned char           RXM1SIDH            @ 0xF1C;
// bit and bitfield definitions
//extern volatile bit SID3               @ ((unsigned)&RXM1SIDH*8)+0;
//extern volatile bit SID4               @ ((unsigned)&RXM1SIDH*8)+1;
//extern volatile bit SID5               @ ((unsigned)&RXM1SIDH*8)+2;
//extern volatile bit SID6               @ ((unsigned)&RXM1SIDH*8)+3;
//extern volatile bit SID7               @ ((unsigned)&RXM1SIDH*8)+4;
//extern volatile bit SID8               @ ((unsigned)&RXM1SIDH*8)+5;
//extern volatile bit SID9               @ ((unsigned)&RXM1SIDH*8)+6;
//extern volatile bit SID10              @ ((unsigned)&RXM1SIDH*8)+7;
extern union {
    struct {
        volatile unsigned SID3                : 1;
        volatile unsigned SID4                : 1;
        volatile unsigned SID5                : 1;
        volatile unsigned SID6                : 1;
        volatile unsigned SID7                : 1;
        volatile unsigned SID8                : 1;
        volatile unsigned SID9                : 1;
        volatile unsigned SID10               : 1;
    };
} RXM1SIDHbits @ 0xF1C;

// Register: RXM1SIDL
extern volatile unsigned char           RXM1SIDL            @ 0xF1D;
// bit and bitfield definitions
//extern volatile bit EID16              @ ((unsigned)&RXM1SIDL*8)+0;
//extern volatile bit EID17              @ ((unsigned)&RXM1SIDL*8)+1;
//extern volatile bit SID0               @ ((unsigned)&RXM1SIDL*8)+5;
//extern volatile bit SID1               @ ((unsigned)&RXM1SIDL*8)+6;
//extern volatile bit SID2               @ ((unsigned)&RXM1SIDL*8)+7;
extern union {
    struct {
        volatile unsigned EID16               : 1;
        volatile unsigned EID17               : 1;
        volatile unsigned                     : 3;
        volatile unsigned SID0                : 1;
        volatile unsigned SID1                : 1;
        volatile unsigned SID2                : 1;
    };
} RXM1SIDLbits @ 0xF1D;

// Register: RXM1EIDH
extern volatile unsigned char           RXM1EIDH            @ 0xF1E;
// bit and bitfield definitions
//extern volatile bit EID8               @ ((unsigned)&RXM1EIDH*8)+0;
//extern volatile bit EID9               @ ((unsigned)&RXM1EIDH*8)+1;
//extern volatile bit EID10              @ ((unsigned)&RXM1EIDH*8)+2;
//extern volatile bit EID11              @ ((unsigned)&RXM1EIDH*8)+3;
//extern volatile bit EID12              @ ((unsigned)&RXM1EIDH*8)+4;
//extern volatile bit EID13              @ ((unsigned)&RXM1EIDH*8)+5;
//extern volatile bit EID14              @ ((unsigned)&RXM1EIDH*8)+6;
//extern volatile bit EID15              @ ((unsigned)&RXM1EIDH*8)+7;
extern union {
    struct {
        volatile unsigned EID8                : 1;
        volatile unsigned EID9                : 1;
        volatile unsigned EID10               : 1;
        volatile unsigned EID11               : 1;
        volatile unsigned EID12               : 1;
        volatile unsigned EID13               : 1;
        volatile unsigned EID14               : 1;
        volatile unsigned EID15               : 1;
    };
} RXM1EIDHbits @ 0xF1E;

// Register: RXM1EIDL
extern volatile unsigned char           RXM1EIDL            @ 0xF1F;
// bit and bitfield definitions
//extern volatile bit EID0               @ ((unsigned)&RXM1EIDL*8)+0;
//extern volatile bit EID1               @ ((unsigned)&RXM1EIDL*8)+1;
//extern volatile bit EID2               @ ((unsigned)&RXM1EIDL*8)+2;
//extern volatile bit EID3               @ ((unsigned)&RXM1EIDL*8)+3;
//extern volatile bit EID4               @ ((unsigned)&RXM1EIDL*8)+4;
//extern volatile bit EID5               @ ((unsigned)&RXM1EIDL*8)+5;
//extern volatile bit EID6               @ ((unsigned)&RXM1EIDL*8)+6;
//extern volatile bit EID7               @ ((unsigned)&RXM1EIDL*8)+7;
extern union {
    struct {
        volatile unsigned EID0                : 1;
        volatile unsigned EID1                : 1;
        volatile unsigned EID2                : 1;
        volatile unsigned EID3                : 1;
        volatile unsigned EID4                : 1;
        volatile unsigned EID5                : 1;
        volatile unsigned EID6                : 1;
        volatile unsigned EID7                : 1;
    };
} RXM1EIDLbits @ 0xF1F;

// Register: TXB2CON
extern volatile unsigned char           TXB2CON             @ 0xF20;
// bit and bitfield definitions
//extern volatile bit TXPRI0             @ ((unsigned)&TXB2CON*8)+0;
//extern volatile bit TXPRI1             @ ((unsigned)&TXB2CON*8)+1;
//extern volatile bit TXREQ              @ ((unsigned)&TXB2CON*8)+3;
//extern volatile bit TXERR              @ ((unsigned)&TXB2CON*8)+4;
//extern volatile bit TXLARB             @ ((unsigned)&TXB2CON*8)+5;
//extern volatile bit TXABT              @ ((unsigned)&TXB2CON*8)+6;
extern union {
    struct {
        volatile unsigned TXPRI0              : 1;
        volatile unsigned TXPRI1              : 1;
        volatile unsigned                     : 1;
        volatile unsigned TXREQ               : 1;
        volatile unsigned TXERR               : 1;
        volatile unsigned TXLARB              : 1;
        volatile unsigned TXABT               : 1;
    };
} TXB2CONbits @ 0xF20;

// Register: TXB2SIDH
extern volatile unsigned char           TXB2SIDH            @ 0xF21;
// bit and bitfield definitions
//extern volatile bit SID3               @ ((unsigned)&TXB2SIDH*8)+0;
//extern volatile bit SID4               @ ((unsigned)&TXB2SIDH*8)+1;
//extern volatile bit SID5               @ ((unsigned)&TXB2SIDH*8)+2;
//extern volatile bit SID6               @ ((unsigned)&TXB2SIDH*8)+3;
//extern volatile bit SID7               @ ((unsigned)&TXB2SIDH*8)+4;
//extern volatile bit SID8               @ ((unsigned)&TXB2SIDH*8)+5;
//extern volatile bit SID9               @ ((unsigned)&TXB2SIDH*8)+6;
//extern volatile bit SID10              @ ((unsigned)&TXB2SIDH*8)+7;
extern union {
    struct {
        volatile unsigned SID3                : 1;
        volatile unsigned SID4                : 1;
        volatile unsigned SID5                : 1;
        volatile unsigned SID6                : 1;
        volatile unsigned SID7                : 1;
        volatile unsigned SID8                : 1;
        volatile unsigned SID9                : 1;
        volatile unsigned SID10               : 1;
    };
} TXB2SIDHbits @ 0xF21;

// Register: TXB2SIDL
extern volatile unsigned char           TXB2SIDL            @ 0xF22;
// bit and bitfield definitions
//extern volatile bit EID16              @ ((unsigned)&TXB2SIDL*8)+0;
//extern volatile bit EID17              @ ((unsigned)&TXB2SIDL*8)+1;
//extern volatile bit EXIDE              @ ((unsigned)&TXB2SIDL*8)+3;
//extern volatile bit SID0               @ ((unsigned)&TXB2SIDL*8)+5;
//extern volatile bit SID1               @ ((unsigned)&TXB2SIDL*8)+6;
//extern volatile bit SID2               @ ((unsigned)&TXB2SIDL*8)+7;
extern union {
    struct {
        volatile unsigned EID16               : 1;
        volatile unsigned EID17               : 1;
        volatile unsigned                     : 1;
        volatile unsigned EXIDE               : 1;
        volatile unsigned : 1;
        volatile unsigned SID0                : 1;
        volatile unsigned SID1                : 1;
        volatile unsigned SID2                : 1;
    };
} TXB2SIDLbits @ 0xF22;

// Register: TXB2EIDH
extern volatile unsigned char           TXB2EIDH            @ 0xF23;
// bit and bitfield definitions
//extern volatile bit EID8               @ ((unsigned)&TXB2EIDH*8)+0;
//extern volatile bit EID9               @ ((unsigned)&TXB2EIDH*8)+1;
//extern volatile bit EID10              @ ((unsigned)&TXB2EIDH*8)+2;
//extern volatile bit EID11              @ ((unsigned)&TXB2EIDH*8)+3;
//extern volatile bit EID12              @ ((unsigned)&TXB2EIDH*8)+4;
//extern volatile bit EID13              @ ((unsigned)&TXB2EIDH*8)+5;
//extern volatile bit EID14              @ ((unsigned)&TXB2EIDH*8)+6;
//extern volatile bit EID15              @ ((unsigned)&TXB2EIDH*8)+7;
extern union {
    struct {
        volatile unsigned EID8                : 1;
        volatile unsigned EID9                : 1;
        volatile unsigned EID10               : 1;
        volatile unsigned EID11               : 1;
        volatile unsigned EID12               : 1;
        volatile unsigned EID13               : 1;
        volatile unsigned EID14               : 1;
        volatile unsigned EID15               : 1;
    };
} TXB2EIDHbits @ 0xF23;

// Register: TXB2EIDL
extern volatile unsigned char           TXB2EIDL            @ 0xF24;
// bit and bitfield definitions
//extern volatile bit EID0               @ ((unsigned)&TXB2EIDL*8)+0;
//extern volatile bit EID1               @ ((unsigned)&TXB2EIDL*8)+1;
//extern volatile bit EID2               @ ((unsigned)&TXB2EIDL*8)+2;
//extern volatile bit EID3               @ ((unsigned)&TXB2EIDL*8)+3;
//extern volatile bit EID4               @ ((unsigned)&TXB2EIDL*8)+4;
//extern volatile bit EID5               @ ((unsigned)&TXB2EIDL*8)+5;
//extern volatile bit EID6               @ ((unsigned)&TXB2EIDL*8)+6;
//extern volatile bit EID7               @ ((unsigned)&TXB2EIDL*8)+7;
extern union {
    struct {
        volatile unsigned EID0                : 1;
        volatile unsigned EID1                : 1;
        volatile unsigned EID2                : 1;
        volatile unsigned EID3                : 1;
        volatile unsigned EID4                : 1;
        volatile unsigned EID5                : 1;
        volatile unsigned EID6                : 1;
        volatile unsigned EID7                : 1;
    };
} TXB2EIDLbits @ 0xF24;

// Register: TXB2DLC
extern volatile unsigned char           TXB2DLC             @ 0xF25;
// bit and bitfield definitions
//extern volatile bit DLC0               @ ((unsigned)&TXB2DLC*8)+0;
//extern volatile bit DLC1               @ ((unsigned)&TXB2DLC*8)+1;
//extern volatile bit DLC2               @ ((unsigned)&TXB2DLC*8)+2;
//extern volatile bit DLC3               @ ((unsigned)&TXB2DLC*8)+3;
//extern volatile bit TXRTR              @ ((unsigned)&TXB2DLC*8)+6;
extern union {
    struct {
        volatile unsigned DLC0                : 1;
        volatile unsigned DLC1                : 1;
        volatile unsigned DLC2                : 1;
        volatile unsigned DLC3                : 1;
        volatile unsigned                     : 2;
        volatile unsigned TXRTR               : 1;
    };
} TXB2DLCbits @ 0xF25;

// Register: TXB2D0
extern volatile unsigned char           TXB2D0              @ 0xF26;
// bit and bitfield definitions
extern volatile bit TXB2D00             @ ((unsigned)&TXB2D0*8)+0;
extern volatile bit TXB2D01             @ ((unsigned)&TXB2D0*8)+1;
extern volatile bit TXB2D02             @ ((unsigned)&TXB2D0*8)+2;
extern volatile bit TXB2D03             @ ((unsigned)&TXB2D0*8)+3;
extern volatile bit TXB2D04             @ ((unsigned)&TXB2D0*8)+4;
extern volatile bit TXB2D05             @ ((unsigned)&TXB2D0*8)+5;
extern volatile bit TXB2D06             @ ((unsigned)&TXB2D0*8)+6;
extern volatile bit TXB2D07             @ ((unsigned)&TXB2D0*8)+7;
extern union {
    struct {
        volatile unsigned TXB2D00             : 1;
        volatile unsigned TXB2D01             : 1;
        volatile unsigned TXB2D02             : 1;
        volatile unsigned TXB2D03             : 1;
        volatile unsigned TXB2D04             : 1;
        volatile unsigned TXB2D05             : 1;
        volatile unsigned TXB2D06             : 1;
        volatile unsigned TXB2D07             : 1;
    };
} TXB2D0bits @ 0xF26;

// Register: TXB2D1
extern volatile unsigned char           TXB2D1              @ 0xF27;
// bit and bitfield definitions
extern volatile bit TXB2D10             @ ((unsigned)&TXB2D1*8)+0;
extern volatile bit TXB2D11             @ ((unsigned)&TXB2D1*8)+1;
extern volatile bit TXB2D12             @ ((unsigned)&TXB2D1*8)+2;
extern volatile bit TXB2D13             @ ((unsigned)&TXB2D1*8)+3;
extern volatile bit TXB2D14             @ ((unsigned)&TXB2D1*8)+4;
extern volatile bit TXB2D15             @ ((unsigned)&TXB2D1*8)+5;
extern volatile bit TXB2D16             @ ((unsigned)&TXB2D1*8)+6;
extern volatile bit TXB2D17             @ ((unsigned)&TXB2D1*8)+7;
extern union {
    struct {
        volatile unsigned TXB2D10             : 1;
        volatile unsigned TXB2D11             : 1;
        volatile unsigned TXB2D12             : 1;
        volatile unsigned TXB2D13             : 1;
        volatile unsigned TXB2D14             : 1;
        volatile unsigned TXB2D15             : 1;
        volatile unsigned TXB2D16             : 1;
        volatile unsigned TXB2D17             : 1;
    };
} TXB2D1bits @ 0xF27;

// Register: TXB2D2
extern volatile unsigned char           TXB2D2              @ 0xF28;
// bit and bitfield definitions
extern volatile bit TXB2D20             @ ((unsigned)&TXB2D2*8)+0;
extern volatile bit TXB2D21             @ ((unsigned)&TXB2D2*8)+1;
extern volatile bit TXB2D22             @ ((unsigned)&TXB2D2*8)+2;
extern volatile bit TXB2D23             @ ((unsigned)&TXB2D2*8)+3;
extern volatile bit TXB2D24             @ ((unsigned)&TXB2D2*8)+4;
extern volatile bit TXB2D25             @ ((unsigned)&TXB2D2*8)+5;
extern volatile bit TXB2D26             @ ((unsigned)&TXB2D2*8)+6;
extern volatile bit TXB2D27             @ ((unsigned)&TXB2D2*8)+7;
extern union {
    struct {
        volatile unsigned TXB2D20             : 1;
        volatile unsigned TXB2D21             : 1;
        volatile unsigned TXB2D22             : 1;
        volatile unsigned TXB2D23             : 1;
        volatile unsigned TXB2D24             : 1;
        volatile unsigned TXB2D25             : 1;
        volatile unsigned TXB2D26             : 1;
        volatile unsigned TXB2D27             : 1;
    };
} TXB2D2bits @ 0xF28;

// Register: TXB2D3
extern volatile unsigned char           TXB2D3              @ 0xF29;
// bit and bitfield definitions
extern volatile bit TXB2D30             @ ((unsigned)&TXB2D3*8)+0;
extern volatile bit TXB2D31             @ ((unsigned)&TXB2D3*8)+1;
extern volatile bit TXB2D32             @ ((unsigned)&TXB2D3*8)+2;
extern volatile bit TXB2D33             @ ((unsigned)&TXB2D3*8)+3;
extern volatile bit TXB2D34             @ ((unsigned)&TXB2D3*8)+4;
extern volatile bit TXB2D35             @ ((unsigned)&TXB2D3*8)+5;
extern volatile bit TXB2D36             @ ((unsigned)&TXB2D3*8)+6;
extern volatile bit TXB2D37             @ ((unsigned)&TXB2D3*8)+7;
extern union {
    struct {
        volatile unsigned TXB2D30             : 1;
        volatile unsigned TXB2D31             : 1;
        volatile unsigned TXB2D32             : 1;
        volatile unsigned TXB2D33             : 1;
        volatile unsigned TXB2D34             : 1;
        volatile unsigned TXB2D35             : 1;
        volatile unsigned TXB2D36             : 1;
        volatile unsigned TXB2D37             : 1;
    };
} TXB2D3bits @ 0xF29;

// Register: TXB2D4
extern volatile unsigned char           TXB2D4              @ 0xF2A;
// bit and bitfield definitions
extern volatile bit TXB2D40             @ ((unsigned)&TXB2D4*8)+0;
extern volatile bit TXB2D41             @ ((unsigned)&TXB2D4*8)+1;
extern volatile bit TXB2D42             @ ((unsigned)&TXB2D4*8)+2;
extern volatile bit TXB2D43             @ ((unsigned)&TXB2D4*8)+3;
extern volatile bit TXB2D44             @ ((unsigned)&TXB2D4*8)+4;
extern volatile bit TXB2D45             @ ((unsigned)&TXB2D4*8)+5;
extern volatile bit TXB2D46             @ ((unsigned)&TXB2D4*8)+6;
extern volatile bit TXB2D47             @ ((unsigned)&TXB2D4*8)+7;
extern union {
    struct {
        volatile unsigned TXB2D40             : 1;
        volatile unsigned TXB2D41             : 1;
        volatile unsigned TXB2D42             : 1;
        volatile unsigned TXB2D43             : 1;
        volatile unsigned TXB2D44             : 1;
        volatile unsigned TXB2D45             : 1;
        volatile unsigned TXB2D46             : 1;
        volatile unsigned TXB2D47             : 1;
    };
} TXB2D4bits @ 0xF2A;

// Register: TXB2D5
extern volatile unsigned char           TXB2D5              @ 0xF2B;
// bit and bitfield definitions
extern volatile bit TXB2D50             @ ((unsigned)&TXB2D5*8)+0;
extern volatile bit TXB2D51             @ ((unsigned)&TXB2D5*8)+1;
extern volatile bit TXB2D52             @ ((unsigned)&TXB2D5*8)+2;
extern volatile bit TXB2D53             @ ((unsigned)&TXB2D5*8)+3;
extern volatile bit TXB2D54             @ ((unsigned)&TXB2D5*8)+4;
extern volatile bit TXB2D55             @ ((unsigned)&TXB2D5*8)+5;
extern volatile bit TXB2D56             @ ((unsigned)&TXB2D5*8)+6;
extern volatile bit TXB2D57             @ ((unsigned)&TXB2D5*8)+7;
extern union {
    struct {
        volatile unsigned TXB2D50             : 1;
        volatile unsigned TXB2D51             : 1;
        volatile unsigned TXB2D52             : 1;
        volatile unsigned TXB2D53             : 1;
        volatile unsigned TXB2D54             : 1;
        volatile unsigned TXB2D55             : 1;
        volatile unsigned TXB2D56             : 1;
        volatile unsigned TXB2D57             : 1;
    };
} TXB2D5bits @ 0xF2B;

// Register: TXB2D6
extern volatile unsigned char           TXB2D6              @ 0xF2C;
// bit and bitfield definitions
extern volatile bit TXB2D60             @ ((unsigned)&TXB2D6*8)+0;
extern volatile bit TXB2D61             @ ((unsigned)&TXB2D6*8)+1;
extern volatile bit TXB2D62             @ ((unsigned)&TXB2D6*8)+2;
extern volatile bit TXB2D63             @ ((unsigned)&TXB2D6*8)+3;
extern volatile bit TXB2D64             @ ((unsigned)&TXB2D6*8)+4;
extern volatile bit TXB2D65             @ ((unsigned)&TXB2D6*8)+5;
extern volatile bit TXB2D66             @ ((unsigned)&TXB2D6*8)+6;
extern volatile bit TXB2D67             @ ((unsigned)&TXB2D6*8)+7;
extern union {
    struct {
        volatile unsigned TXB2D60             : 1;
        volatile unsigned TXB2D61             : 1;
        volatile unsigned TXB2D62             : 1;
        volatile unsigned TXB2D63             : 1;
        volatile unsigned TXB2D64             : 1;
        volatile unsigned TXB2D65             : 1;
        volatile unsigned TXB2D66             : 1;
        volatile unsigned TXB2D67             : 1;
    };
} TXB2D6bits @ 0xF2C;

// Register: TXB2D7
extern volatile unsigned char           TXB2D7              @ 0xF2D;
// bit and bitfield definitions
extern volatile bit TXB2D70             @ ((unsigned)&TXB2D7*8)+0;
extern volatile bit TXB2D71             @ ((unsigned)&TXB2D7*8)+1;
extern volatile bit TXB2D72             @ ((unsigned)&TXB2D7*8)+2;
extern volatile bit TXB2D73             @ ((unsigned)&TXB2D7*8)+3;
extern volatile bit TXB2D74             @ ((unsigned)&TXB2D7*8)+4;
extern volatile bit TXB2D75             @ ((unsigned)&TXB2D7*8)+5;
extern volatile bit TXB2D76             @ ((unsigned)&TXB2D7*8)+6;
extern volatile bit TXB2D77             @ ((unsigned)&TXB2D7*8)+7;
extern union {
    struct {
        volatile unsigned TXB2D70             : 1;
        volatile unsigned TXB2D71             : 1;
        volatile unsigned TXB2D72             : 1;
        volatile unsigned TXB2D73             : 1;
        volatile unsigned TXB2D74             : 1;
        volatile unsigned TXB2D75             : 1;
        volatile unsigned TXB2D76             : 1;
        volatile unsigned TXB2D77             : 1;
    };
} TXB2D7bits @ 0xF2D;

// Register: CANSTATRO4
extern volatile unsigned char           CANSTATRO4          @ 0xF2E;
// bit and bitfield definitions
//extern volatile bit ICODE0             @ ((unsigned)&CANSTATRO4*8)+1;
//extern volatile bit ICODE1             @ ((unsigned)&CANSTATRO4*8)+2;
//extern volatile bit ICODE2             @ ((unsigned)&CANSTATRO4*8)+3;
//extern volatile bit OPMODE0            @ ((unsigned)&CANSTATRO4*8)+5;
//extern volatile bit OPMODE1            @ ((unsigned)&CANSTATRO4*8)+6;
//extern volatile bit OPMODE2            @ ((unsigned)&CANSTATRO4*8)+7;
extern union {
    struct {
        volatile unsigned                     : 1;
        volatile unsigned ICODE0              : 1;
        volatile unsigned ICODE1              : 1;
        volatile unsigned ICODE2              : 1;
        volatile unsigned : 1;
        volatile unsigned OPMODE0             : 1;
        volatile unsigned OPMODE1             : 1;
        volatile unsigned OPMODE2             : 1;
    };
} CANSTATRO4bits @ 0xF2E;

// Register: TXB1CON
extern volatile unsigned char           TXB1CON             @ 0xF30;
// bit and bitfield definitions
//extern volatile bit TXPRI0             @ ((unsigned)&TXB1CON*8)+0;
//extern volatile bit TXPRI1             @ ((unsigned)&TXB1CON*8)+1;
//extern volatile bit TXREQ              @ ((unsigned)&TXB1CON*8)+3;
//extern volatile bit TXERR              @ ((unsigned)&TXB1CON*8)+4;
//extern volatile bit TXLARB             @ ((unsigned)&TXB1CON*8)+5;
//extern volatile bit TXABT              @ ((unsigned)&TXB1CON*8)+6;
extern union {
    struct {
        volatile unsigned TXPRI0              : 1;
        volatile unsigned TXPRI1              : 1;
        volatile unsigned                     : 1;
        volatile unsigned TXREQ               : 1;
        volatile unsigned TXERR               : 1;
        volatile unsigned TXLARB              : 1;
        volatile unsigned TXABT               : 1;
    };
} TXB1CONbits @ 0xF30;

// Register: TXB1SIDH
extern volatile unsigned char           TXB1SIDH            @ 0xF31;
// bit and bitfield definitions
//extern volatile bit SID3               @ ((unsigned)&TXB1SIDH*8)+0;
//extern volatile bit SID4               @ ((unsigned)&TXB1SIDH*8)+1;
//extern volatile bit SID5               @ ((unsigned)&TXB1SIDH*8)+2;
//extern volatile bit SID6               @ ((unsigned)&TXB1SIDH*8)+3;
//extern volatile bit SID7               @ ((unsigned)&TXB1SIDH*8)+4;
//extern volatile bit SID8               @ ((unsigned)&TXB1SIDH*8)+5;
//extern volatile bit SID9               @ ((unsigned)&TXB1SIDH*8)+6;
//extern volatile bit SID10              @ ((unsigned)&TXB1SIDH*8)+7;
extern union {
    struct {
        volatile unsigned SID3                : 1;
        volatile unsigned SID4                : 1;
        volatile unsigned SID5                : 1;
        volatile unsigned SID6                : 1;
        volatile unsigned SID7                : 1;
        volatile unsigned SID8                : 1;
        volatile unsigned SID9                : 1;
        volatile unsigned SID10               : 1;
    };
} TXB1SIDHbits @ 0xF31;

// Register: TXB1SIDL
extern volatile unsigned char           TXB1SIDL            @ 0xF32;
// bit and bitfield definitions
//extern volatile bit EID16              @ ((unsigned)&TXB1SIDL*8)+0;
//extern volatile bit EID17              @ ((unsigned)&TXB1SIDL*8)+1;
//extern volatile bit EXIDE              @ ((unsigned)&TXB1SIDL*8)+3;
//extern volatile bit SID0               @ ((unsigned)&TXB1SIDL*8)+5;
//extern volatile bit SID1               @ ((unsigned)&TXB1SIDL*8)+6;
//extern volatile bit SID2               @ ((unsigned)&TXB1SIDL*8)+7;
extern union {
    struct {
        volatile unsigned EID16               : 1;
        volatile unsigned EID17               : 1;
        volatile unsigned                     : 1;
        volatile unsigned EXIDE               : 1;
        volatile unsigned : 1;
        volatile unsigned SID0                : 1;
        volatile unsigned SID1                : 1;
        volatile unsigned SID2                : 1;
    };
} TXB1SIDLbits @ 0xF32;

// Register: TXB1EIDH
extern volatile unsigned char           TXB1EIDH            @ 0xF33;
// bit and bitfield definitions
//extern volatile bit EID8               @ ((unsigned)&TXB1EIDH*8)+0;
//extern volatile bit EID9               @ ((unsigned)&TXB1EIDH*8)+1;
//extern volatile bit EID10              @ ((unsigned)&TXB1EIDH*8)+2;
//extern volatile bit EID11              @ ((unsigned)&TXB1EIDH*8)+3;
//extern volatile bit EID12              @ ((unsigned)&TXB1EIDH*8)+4;
//extern volatile bit EID13              @ ((unsigned)&TXB1EIDH*8)+5;
//extern volatile bit EID14              @ ((unsigned)&TXB1EIDH*8)+6;
//extern volatile bit EID15              @ ((unsigned)&TXB1EIDH*8)+7;
extern union {
    struct {
        volatile unsigned EID8                : 1;
        volatile unsigned EID9                : 1;
        volatile unsigned EID10               : 1;
        volatile unsigned EID11               : 1;
        volatile unsigned EID12               : 1;
        volatile unsigned EID13               : 1;
        volatile unsigned EID14               : 1;
        volatile unsigned EID15               : 1;
    };
} TXB1EIDHbits @ 0xF33;

// Register: TXB1EIDL
extern volatile unsigned char           TXB1EIDL            @ 0xF34;
// bit and bitfield definitions
//extern volatile bit EID0               @ ((unsigned)&TXB1EIDL*8)+0;
//extern volatile bit EID1               @ ((unsigned)&TXB1EIDL*8)+1;
//extern volatile bit EID2               @ ((unsigned)&TXB1EIDL*8)+2;
//extern volatile bit EID3               @ ((unsigned)&TXB1EIDL*8)+3;
//extern volatile bit EID4               @ ((unsigned)&TXB1EIDL*8)+4;
//extern volatile bit EID5               @ ((unsigned)&TXB1EIDL*8)+5;
//extern volatile bit EID6               @ ((unsigned)&TXB1EIDL*8)+6;
//extern volatile bit EID7               @ ((unsigned)&TXB1EIDL*8)+7;
extern union {
    struct {
        volatile unsigned EID0                : 1;
        volatile unsigned EID1                : 1;
        volatile unsigned EID2                : 1;
        volatile unsigned EID3                : 1;
        volatile unsigned EID4                : 1;
        volatile unsigned EID5                : 1;
        volatile unsigned EID6                : 1;
        volatile unsigned EID7                : 1;
    };
} TXB1EIDLbits @ 0xF34;

// Register: TXB1DLC
extern volatile unsigned char           TXB1DLC             @ 0xF35;
// bit and bitfield definitions
//extern volatile bit DLC0               @ ((unsigned)&TXB1DLC*8)+0;
//extern volatile bit DLC1               @ ((unsigned)&TXB1DLC*8)+1;
//extern volatile bit DLC2               @ ((unsigned)&TXB1DLC*8)+2;
//extern volatile bit DLC3               @ ((unsigned)&TXB1DLC*8)+3;
//extern volatile bit TXRTR              @ ((unsigned)&TXB1DLC*8)+6;
extern union {
    struct {
        volatile unsigned DLC0                : 1;
        volatile unsigned DLC1                : 1;
        volatile unsigned DLC2                : 1;
        volatile unsigned DLC3                : 1;
        volatile unsigned                     : 2;
        volatile unsigned TXRTR               : 1;
    };
} TXB1DLCbits @ 0xF35;

// Register: TXB1D0
extern volatile unsigned char           TXB1D0              @ 0xF36;
// bit and bitfield definitions
extern volatile bit TXB1D00             @ ((unsigned)&TXB1D0*8)+0;
extern volatile bit TXB1D01             @ ((unsigned)&TXB1D0*8)+1;
extern volatile bit TXB1D02             @ ((unsigned)&TXB1D0*8)+2;
extern volatile bit TXB1D03             @ ((unsigned)&TXB1D0*8)+3;
extern volatile bit TXB1D04             @ ((unsigned)&TXB1D0*8)+4;
extern volatile bit TXB1D05             @ ((unsigned)&TXB1D0*8)+5;
extern volatile bit TXB1D06             @ ((unsigned)&TXB1D0*8)+6;
extern volatile bit TXB1D07             @ ((unsigned)&TXB1D0*8)+7;
extern union {
    struct {
        volatile unsigned TXB1D00             : 1;
        volatile unsigned TXB1D01             : 1;
        volatile unsigned TXB1D02             : 1;
        volatile unsigned TXB1D03             : 1;
        volatile unsigned TXB1D04             : 1;
        volatile unsigned TXB1D05             : 1;
        volatile unsigned TXB1D06             : 1;
        volatile unsigned TXB1D07             : 1;
    };
} TXB1D0bits @ 0xF36;

// Register: TXB1D1
extern volatile unsigned char           TXB1D1              @ 0xF37;
// bit and bitfield definitions
extern volatile bit TXB1D10             @ ((unsigned)&TXB1D1*8)+0;
extern volatile bit TXB1D11             @ ((unsigned)&TXB1D1*8)+1;
extern volatile bit TXB1D12             @ ((unsigned)&TXB1D1*8)+2;
extern volatile bit TXB1D13             @ ((unsigned)&TXB1D1*8)+3;
extern volatile bit TXB1D14             @ ((unsigned)&TXB1D1*8)+4;
extern volatile bit TXB1D15             @ ((unsigned)&TXB1D1*8)+5;
extern volatile bit TXB1D16             @ ((unsigned)&TXB1D1*8)+6;
extern volatile bit TXB1D17             @ ((unsigned)&TXB1D1*8)+7;
extern union {
    struct {
        volatile unsigned TXB1D10             : 1;
        volatile unsigned TXB1D11             : 1;
        volatile unsigned TXB1D12             : 1;
        volatile unsigned TXB1D13             : 1;
        volatile unsigned TXB1D14             : 1;
        volatile unsigned TXB1D15             : 1;
        volatile unsigned TXB1D16             : 1;
        volatile unsigned TXB1D17             : 1;
    };
} TXB1D1bits @ 0xF37;

// Register: TXB1D2
extern volatile unsigned char           TXB1D2              @ 0xF38;
// bit and bitfield definitions
extern volatile bit TXB1D20             @ ((unsigned)&TXB1D2*8)+0;
extern volatile bit TXB1D21             @ ((unsigned)&TXB1D2*8)+1;
extern volatile bit TXB1D22             @ ((unsigned)&TXB1D2*8)+2;
extern volatile bit TXB1D23             @ ((unsigned)&TXB1D2*8)+3;
extern volatile bit TXB1D24             @ ((unsigned)&TXB1D2*8)+4;
extern volatile bit TXB1D25             @ ((unsigned)&TXB1D2*8)+5;
extern volatile bit TXB1D26             @ ((unsigned)&TXB1D2*8)+6;
extern volatile bit TXB1D27             @ ((unsigned)&TXB1D2*8)+7;
extern volatile bit TBB1D23             @ ((unsigned)&TXB1D2*8)+3;
extern union {
    struct {
        volatile unsigned TXB1D20             : 1;
        volatile unsigned TXB1D21             : 1;
        volatile unsigned TXB1D22             : 1;
        volatile unsigned TXB1D23             : 1;
        volatile unsigned TXB1D24             : 1;
        volatile unsigned TXB1D25             : 1;
        volatile unsigned TXB1D26             : 1;
        volatile unsigned TXB1D27             : 1;
    };
    struct {
        volatile unsigned                     : 3;
        volatile unsigned TBB1D23             : 1;
    };
} TXB1D2bits @ 0xF38;

// Register: TXB1D3
extern volatile unsigned char           TXB1D3              @ 0xF39;
// bit and bitfield definitions
extern volatile bit TXB1D30             @ ((unsigned)&TXB1D3*8)+0;
extern volatile bit TXB1D31             @ ((unsigned)&TXB1D3*8)+1;
extern volatile bit TXB1D32             @ ((unsigned)&TXB1D3*8)+2;
extern volatile bit TXB1D33             @ ((unsigned)&TXB1D3*8)+3;
extern volatile bit TXB1D34             @ ((unsigned)&TXB1D3*8)+4;
extern volatile bit TXB1D35             @ ((unsigned)&TXB1D3*8)+5;
extern volatile bit TXB1D36             @ ((unsigned)&TXB1D3*8)+6;
extern volatile bit TXB1D37             @ ((unsigned)&TXB1D3*8)+7;
extern union {
    struct {
        volatile unsigned TXB1D30             : 1;
        volatile unsigned TXB1D31             : 1;
        volatile unsigned TXB1D32             : 1;
        volatile unsigned TXB1D33             : 1;
        volatile unsigned TXB1D34             : 1;
        volatile unsigned TXB1D35             : 1;
        volatile unsigned TXB1D36             : 1;
        volatile unsigned TXB1D37             : 1;
    };
} TXB1D3bits @ 0xF39;

// Register: TXB1D4
extern volatile unsigned char           TXB1D4              @ 0xF3A;
// bit and bitfield definitions
extern volatile bit TXB1D40             @ ((unsigned)&TXB1D4*8)+0;
extern volatile bit TXB1D41             @ ((unsigned)&TXB1D4*8)+1;
extern volatile bit TXB1D42             @ ((unsigned)&TXB1D4*8)+2;
extern volatile bit TXB1D43             @ ((unsigned)&TXB1D4*8)+3;
extern volatile bit TXB1D44             @ ((unsigned)&TXB1D4*8)+4;
extern volatile bit TXB1D45             @ ((unsigned)&TXB1D4*8)+5;
extern volatile bit TXB1D46             @ ((unsigned)&TXB1D4*8)+6;
extern volatile bit TXB1D47             @ ((unsigned)&TXB1D4*8)+7;
extern union {
    struct {
        volatile unsigned TXB1D40             : 1;
        volatile unsigned TXB1D41             : 1;
        volatile unsigned TXB1D42             : 1;
        volatile unsigned TXB1D43             : 1;
        volatile unsigned TXB1D44             : 1;
        volatile unsigned TXB1D45             : 1;
        volatile unsigned TXB1D46             : 1;
        volatile unsigned TXB1D47             : 1;
    };
} TXB1D4bits @ 0xF3A;

// Register: TXB1D5
extern volatile unsigned char           TXB1D5              @ 0xF3B;
// bit and bitfield definitions
extern volatile bit TXB1D50             @ ((unsigned)&TXB1D5*8)+0;
extern volatile bit TXB1D51             @ ((unsigned)&TXB1D5*8)+1;
extern volatile bit TXB1D52             @ ((unsigned)&TXB1D5*8)+2;
extern volatile bit TXB1D53             @ ((unsigned)&TXB1D5*8)+3;
extern volatile bit TXB1D54             @ ((unsigned)&TXB1D5*8)+4;
extern volatile bit TXB1D55             @ ((unsigned)&TXB1D5*8)+5;
extern volatile bit TXB1D56             @ ((unsigned)&TXB1D5*8)+6;
extern volatile bit TXB1D57             @ ((unsigned)&TXB1D5*8)+7;
extern union {
    struct {
        volatile unsigned TXB1D50             : 1;
        volatile unsigned TXB1D51             : 1;
        volatile unsigned TXB1D52             : 1;
        volatile unsigned TXB1D53             : 1;
        volatile unsigned TXB1D54             : 1;
        volatile unsigned TXB1D55             : 1;
        volatile unsigned TXB1D56             : 1;
        volatile unsigned TXB1D57             : 1;
    };
} TXB1D5bits @ 0xF3B;

// Register: TXB1D6
extern volatile unsigned char           TXB1D6              @ 0xF3C;
// bit and bitfield definitions
extern volatile bit TXB1D60             @ ((unsigned)&TXB1D6*8)+0;
extern volatile bit TXB1D61             @ ((unsigned)&TXB1D6*8)+1;
extern volatile bit TXB1D62             @ ((unsigned)&TXB1D6*8)+2;
extern volatile bit TXB1D63             @ ((unsigned)&TXB1D6*8)+3;
extern volatile bit TXB1D64             @ ((unsigned)&TXB1D6*8)+4;
extern volatile bit TXB1D65             @ ((unsigned)&TXB1D6*8)+5;
extern volatile bit TXB1D66             @ ((unsigned)&TXB1D6*8)+6;
extern volatile bit TXB1D67             @ ((unsigned)&TXB1D6*8)+7;
extern union {
    struct {
        volatile unsigned TXB1D60             : 1;
        volatile unsigned TXB1D61             : 1;
        volatile unsigned TXB1D62             : 1;
        volatile unsigned TXB1D63             : 1;
        volatile unsigned TXB1D64             : 1;
        volatile unsigned TXB1D65             : 1;
        volatile unsigned TXB1D66             : 1;
        volatile unsigned TXB1D67             : 1;
    };
} TXB1D6bits @ 0xF3C;

// Register: TXB1D7
extern volatile unsigned char           TXB1D7              @ 0xF3D;
// bit and bitfield definitions
extern volatile bit TXB1D70             @ ((unsigned)&TXB1D7*8)+0;
extern volatile bit TXB1D71             @ ((unsigned)&TXB1D7*8)+1;
extern volatile bit TXB1D72             @ ((unsigned)&TXB1D7*8)+2;
extern volatile bit TXB1D73             @ ((unsigned)&TXB1D7*8)+3;
extern volatile bit TXB1D74             @ ((unsigned)&TXB1D7*8)+4;
extern volatile bit TXB1D75             @ ((unsigned)&TXB1D7*8)+5;
extern volatile bit TXB1D76             @ ((unsigned)&TXB1D7*8)+6;
extern volatile bit TXB1D77             @ ((unsigned)&TXB1D7*8)+7;
extern union {
    struct {
        volatile unsigned TXB1D70             : 1;
        volatile unsigned TXB1D71             : 1;
        volatile unsigned TXB1D72             : 1;
        volatile unsigned TXB1D73             : 1;
        volatile unsigned TXB1D74             : 1;
        volatile unsigned TXB1D75             : 1;
        volatile unsigned TXB1D76             : 1;
        volatile unsigned TXB1D77             : 1;
    };
} TXB1D7bits @ 0xF3D;

// Register: CANSTATRO3
extern volatile unsigned char           CANSTATRO3          @ 0xF3E;
// bit and bitfield definitions
//extern volatile bit ICODE0             @ ((unsigned)&CANSTATRO3*8)+1;
//extern volatile bit ICODE1             @ ((unsigned)&CANSTATRO3*8)+2;
//extern volatile bit ICODE2             @ ((unsigned)&CANSTATRO3*8)+3;
//extern volatile bit OPMODE0            @ ((unsigned)&CANSTATRO3*8)+5;
//extern volatile bit OPMODE1            @ ((unsigned)&CANSTATRO3*8)+6;
//extern volatile bit OPMODE2            @ ((unsigned)&CANSTATRO3*8)+7;
extern union {
    struct {
        volatile unsigned                     : 1;
        volatile unsigned ICODE0              : 1;
        volatile unsigned ICODE1              : 1;
        volatile unsigned ICODE2              : 1;
        volatile unsigned : 1;
        volatile unsigned OPMODE0             : 1;
        volatile unsigned OPMODE1             : 1;
        volatile unsigned OPMODE2             : 1;
    };
} CANSTATRO3bits @ 0xF3E;

// Register: TXB0CON
extern volatile unsigned char           TXB0CON             @ 0xF40;
// bit and bitfield definitions
//extern volatile bit TXPRI0             @ ((unsigned)&TXB0CON*8)+0;
//extern volatile bit TXPRI1             @ ((unsigned)&TXB0CON*8)+1;
//extern volatile bit TXREQ              @ ((unsigned)&TXB0CON*8)+3;
//extern volatile bit TXERR              @ ((unsigned)&TXB0CON*8)+4;
//extern volatile bit TXLARB             @ ((unsigned)&TXB0CON*8)+5;
//extern volatile bit TXABT              @ ((unsigned)&TXB0CON*8)+6;
extern union {
    struct {
        volatile unsigned TXPRI0              : 1;
        volatile unsigned TXPRI1              : 1;
        volatile unsigned                     : 1;
        volatile unsigned TXREQ               : 1;
        volatile unsigned TXERR               : 1;
        volatile unsigned TXLARB              : 1;
        volatile unsigned TXABT               : 1;
    };
} TXB0CONbits @ 0xF40;

// Register: TXB0SIDH
extern volatile unsigned char           TXB0SIDH            @ 0xF41;
// bit and bitfield definitions
//extern volatile bit SID3               @ ((unsigned)&TXB0SIDH*8)+0;
//extern volatile bit SID4               @ ((unsigned)&TXB0SIDH*8)+1;
//extern volatile bit SID5               @ ((unsigned)&TXB0SIDH*8)+2;
//extern volatile bit SID6               @ ((unsigned)&TXB0SIDH*8)+3;
//extern volatile bit SID7               @ ((unsigned)&TXB0SIDH*8)+4;
//extern volatile bit SID8               @ ((unsigned)&TXB0SIDH*8)+5;
//extern volatile bit SID9               @ ((unsigned)&TXB0SIDH*8)+6;
//extern volatile bit SID10              @ ((unsigned)&TXB0SIDH*8)+7;
extern union {
    struct {
        volatile unsigned SID3                : 1;
        volatile unsigned SID4                : 1;
        volatile unsigned SID5                : 1;
        volatile unsigned SID6                : 1;
        volatile unsigned SID7                : 1;
        volatile unsigned SID8                : 1;
        volatile unsigned SID9                : 1;
        volatile unsigned SID10               : 1;
    };
} TXB0SIDHbits @ 0xF41;

// Register: TXB0SIDL
extern volatile unsigned char           TXB0SIDL            @ 0xF42;
// bit and bitfield definitions
//extern volatile bit EID16              @ ((unsigned)&TXB0SIDL*8)+0;
//extern volatile bit EID17              @ ((unsigned)&TXB0SIDL*8)+1;
//extern volatile bit EXIDE              @ ((unsigned)&TXB0SIDL*8)+3;
//extern volatile bit SID0               @ ((unsigned)&TXB0SIDL*8)+5;
//extern volatile bit SID1               @ ((unsigned)&TXB0SIDL*8)+6;
//extern volatile bit SID2               @ ((unsigned)&TXB0SIDL*8)+7;
extern union {
    struct {
        volatile unsigned EID16               : 1;
        volatile unsigned EID17               : 1;
        volatile unsigned                     : 1;
        volatile unsigned EXIDE               : 1;
        volatile unsigned : 1;
        volatile unsigned SID0                : 1;
        volatile unsigned SID1                : 1;
        volatile unsigned SID2                : 1;
    };
} TXB0SIDLbits @ 0xF42;

// Register: TXB0EIDH
extern volatile unsigned char           TXB0EIDH            @ 0xF43;
// bit and bitfield definitions
//extern volatile bit EID8               @ ((unsigned)&TXB0EIDH*8)+0;
//extern volatile bit EID9               @ ((unsigned)&TXB0EIDH*8)+1;
//extern volatile bit EID10              @ ((unsigned)&TXB0EIDH*8)+2;
//extern volatile bit EID11              @ ((unsigned)&TXB0EIDH*8)+3;
//extern volatile bit EID12              @ ((unsigned)&TXB0EIDH*8)+4;
//extern volatile bit EID13              @ ((unsigned)&TXB0EIDH*8)+5;
//extern volatile bit EID14              @ ((unsigned)&TXB0EIDH*8)+6;
//extern volatile bit EID15              @ ((unsigned)&TXB0EIDH*8)+7;
extern union {
    struct {
        volatile unsigned EID8                : 1;
        volatile unsigned EID9                : 1;
        volatile unsigned EID10               : 1;
        volatile unsigned EID11               : 1;
        volatile unsigned EID12               : 1;
        volatile unsigned EID13               : 1;
        volatile unsigned EID14               : 1;
        volatile unsigned EID15               : 1;
    };
} TXB0EIDHbits @ 0xF43;

// Register: TXB0EIDL
extern volatile unsigned char           TXB0EIDL            @ 0xF44;
// bit and bitfield definitions
//extern volatile bit EID0               @ ((unsigned)&TXB0EIDL*8)+0;
//extern volatile bit EID1               @ ((unsigned)&TXB0EIDL*8)+1;
//extern volatile bit EID2               @ ((unsigned)&TXB0EIDL*8)+2;
//extern volatile bit EID3               @ ((unsigned)&TXB0EIDL*8)+3;
//extern volatile bit EID4               @ ((unsigned)&TXB0EIDL*8)+4;
//extern volatile bit EID5               @ ((unsigned)&TXB0EIDL*8)+5;
//extern volatile bit EID6               @ ((unsigned)&TXB0EIDL*8)+6;
//extern volatile bit EID7               @ ((unsigned)&TXB0EIDL*8)+7;
extern union {
    struct {
        volatile unsigned EID0                : 1;
        volatile unsigned EID1                : 1;
        volatile unsigned EID2                : 1;
        volatile unsigned EID3                : 1;
        volatile unsigned EID4                : 1;
        volatile unsigned EID5                : 1;
        volatile unsigned EID6                : 1;
        volatile unsigned EID7                : 1;
    };
} TXB0EIDLbits @ 0xF44;

// Register: TXB0DLC
extern volatile unsigned char           TXB0DLC             @ 0xF45;
// bit and bitfield definitions
//extern volatile bit DLC0               @ ((unsigned)&TXB0DLC*8)+0;
//extern volatile bit DLC1               @ ((unsigned)&TXB0DLC*8)+1;
//extern volatile bit DLC2               @ ((unsigned)&TXB0DLC*8)+2;
//extern volatile bit DLC3               @ ((unsigned)&TXB0DLC*8)+3;
//extern volatile bit TXRTR              @ ((unsigned)&TXB0DLC*8)+6;
extern union {
    struct {
        volatile unsigned DLC0                : 1;
        volatile unsigned DLC1                : 1;
        volatile unsigned DLC2                : 1;
        volatile unsigned DLC3                : 1;
        volatile unsigned                     : 2;
        volatile unsigned TXRTR               : 1;
    };
} TXB0DLCbits @ 0xF45;

// Register: TXB0D0
extern volatile unsigned char           TXB0D0              @ 0xF46;
// bit and bitfield definitions
extern volatile bit TXB0D00             @ ((unsigned)&TXB0D0*8)+0;
extern volatile bit TXB0D01             @ ((unsigned)&TXB0D0*8)+1;
extern volatile bit TXB0D02             @ ((unsigned)&TXB0D0*8)+2;
extern volatile bit TXB0D03             @ ((unsigned)&TXB0D0*8)+3;
extern volatile bit TXB0D04             @ ((unsigned)&TXB0D0*8)+4;
extern volatile bit TXB0D05             @ ((unsigned)&TXB0D0*8)+5;
extern volatile bit TXB0D06             @ ((unsigned)&TXB0D0*8)+6;
extern volatile bit TXB0D07             @ ((unsigned)&TXB0D0*8)+7;
extern union {
    struct {
        volatile unsigned TXB0D00             : 1;
        volatile unsigned TXB0D01             : 1;
        volatile unsigned TXB0D02             : 1;
        volatile unsigned TXB0D03             : 1;
        volatile unsigned TXB0D04             : 1;
        volatile unsigned TXB0D05             : 1;
        volatile unsigned TXB0D06             : 1;
        volatile unsigned TXB0D07             : 1;
    };
} TXB0D0bits @ 0xF46;

// Register: TXB0D1
extern volatile unsigned char           TXB0D1              @ 0xF47;
// bit and bitfield definitions
extern volatile bit TXB0D10             @ ((unsigned)&TXB0D1*8)+0;
extern volatile bit TXB0D11             @ ((unsigned)&TXB0D1*8)+1;
extern volatile bit TXB0D12             @ ((unsigned)&TXB0D1*8)+2;
extern volatile bit TXB0D13             @ ((unsigned)&TXB0D1*8)+3;
extern volatile bit TXB0D14             @ ((unsigned)&TXB0D1*8)+4;
extern volatile bit TXB0D15             @ ((unsigned)&TXB0D1*8)+5;
extern volatile bit TXB0D16             @ ((unsigned)&TXB0D1*8)+6;
extern volatile bit TXB0D17             @ ((unsigned)&TXB0D1*8)+7;
extern union {
    struct {
        volatile unsigned TXB0D10             : 1;
        volatile unsigned TXB0D11             : 1;
        volatile unsigned TXB0D12             : 1;
        volatile unsigned TXB0D13             : 1;
        volatile unsigned TXB0D14             : 1;
        volatile unsigned TXB0D15             : 1;
        volatile unsigned TXB0D16             : 1;
        volatile unsigned TXB0D17             : 1;
    };
} TXB0D1bits @ 0xF47;

// Register: TXB0D2
extern volatile unsigned char           TXB0D2              @ 0xF48;
// bit and bitfield definitions
extern volatile bit TXB0D20             @ ((unsigned)&TXB0D2*8)+0;
extern volatile bit TXB0D21             @ ((unsigned)&TXB0D2*8)+1;
extern volatile bit TXB0D22             @ ((unsigned)&TXB0D2*8)+2;
extern volatile bit TXB0D23             @ ((unsigned)&TXB0D2*8)+3;
extern volatile bit TXB0D24             @ ((unsigned)&TXB0D2*8)+4;
extern volatile bit TXB0D25             @ ((unsigned)&TXB0D2*8)+5;
extern volatile bit TXB0D26             @ ((unsigned)&TXB0D2*8)+6;
extern volatile bit TXB0D27             @ ((unsigned)&TXB0D2*8)+7;
extern union {
    struct {
        volatile unsigned TXB0D20             : 1;
        volatile unsigned TXB0D21             : 1;
        volatile unsigned TXB0D22             : 1;
        volatile unsigned TXB0D23             : 1;
        volatile unsigned TXB0D24             : 1;
        volatile unsigned TXB0D25             : 1;
        volatile unsigned TXB0D26             : 1;
        volatile unsigned TXB0D27             : 1;
    };
} TXB0D2bits @ 0xF48;

// Register: TXB0D3
extern volatile unsigned char           TXB0D3              @ 0xF49;
// bit and bitfield definitions
extern volatile bit TXB0D30             @ ((unsigned)&TXB0D3*8)+0;
extern volatile bit TXB0D31             @ ((unsigned)&TXB0D3*8)+1;
extern volatile bit TXB0D32             @ ((unsigned)&TXB0D3*8)+2;
extern volatile bit TXB0D33             @ ((unsigned)&TXB0D3*8)+3;
extern volatile bit TXB0D34             @ ((unsigned)&TXB0D3*8)+4;
extern volatile bit TXB0D35             @ ((unsigned)&TXB0D3*8)+5;
extern volatile bit TXB0D36             @ ((unsigned)&TXB0D3*8)+6;
extern volatile bit TXB0D37             @ ((unsigned)&TXB0D3*8)+7;
extern union {
    struct {
        volatile unsigned TXB0D30             : 1;
        volatile unsigned TXB0D31             : 1;
        volatile unsigned TXB0D32             : 1;
        volatile unsigned TXB0D33             : 1;
        volatile unsigned TXB0D34             : 1;
        volatile unsigned TXB0D35             : 1;
        volatile unsigned TXB0D36             : 1;
        volatile unsigned TXB0D37             : 1;
    };
} TXB0D3bits @ 0xF49;

// Register: TXB0D4
extern volatile unsigned char           TXB0D4              @ 0xF4A;
// bit and bitfield definitions
extern volatile bit TXB0D40             @ ((unsigned)&TXB0D4*8)+0;
extern volatile bit TXB0D41             @ ((unsigned)&TXB0D4*8)+1;
extern volatile bit TXB0D42             @ ((unsigned)&TXB0D4*8)+2;
extern volatile bit TXB0D43             @ ((unsigned)&TXB0D4*8)+3;
extern volatile bit TXB0D44             @ ((unsigned)&TXB0D4*8)+4;
extern volatile bit TXB0D45             @ ((unsigned)&TXB0D4*8)+5;
extern volatile bit TXB0D46             @ ((unsigned)&TXB0D4*8)+6;
extern volatile bit TXB0D47             @ ((unsigned)&TXB0D4*8)+7;
extern union {
    struct {
        volatile unsigned TXB0D40             : 1;
        volatile unsigned TXB0D41             : 1;
        volatile unsigned TXB0D42             : 1;
        volatile unsigned TXB0D43             : 1;
        volatile unsigned TXB0D44             : 1;
        volatile unsigned TXB0D45             : 1;
        volatile unsigned TXB0D46             : 1;
        volatile unsigned TXB0D47             : 1;
    };
} TXB0D4bits @ 0xF4A;

// Register: TXB0D5
extern volatile unsigned char           TXB0D5              @ 0xF4B;
// bit and bitfield definitions
extern volatile bit TXB0D50             @ ((unsigned)&TXB0D5*8)+0;
extern volatile bit TXB0D51             @ ((unsigned)&TXB0D5*8)+1;
extern volatile bit TXB0D52             @ ((unsigned)&TXB0D5*8)+2;
extern volatile bit TXB0D53             @ ((unsigned)&TXB0D5*8)+3;
extern volatile bit TXB0D54             @ ((unsigned)&TXB0D5*8)+4;
extern volatile bit TXB0D55             @ ((unsigned)&TXB0D5*8)+5;
extern volatile bit TXB0D56             @ ((unsigned)&TXB0D5*8)+6;
extern volatile bit TXB0D57             @ ((unsigned)&TXB0D5*8)+7;
extern union {
    struct {
        volatile unsigned TXB0D50             : 1;
        volatile unsigned TXB0D51             : 1;
        volatile unsigned TXB0D52             : 1;
        volatile unsigned TXB0D53             : 1;
        volatile unsigned TXB0D54             : 1;
        volatile unsigned TXB0D55             : 1;
        volatile unsigned TXB0D56             : 1;
        volatile unsigned TXB0D57             : 1;
    };
} TXB0D5bits @ 0xF4B;

// Register: TXB0D6
extern volatile unsigned char           TXB0D6              @ 0xF4C;
// bit and bitfield definitions
extern volatile bit TXB0D60             @ ((unsigned)&TXB0D6*8)+0;
extern volatile bit TXB0D61             @ ((unsigned)&TXB0D6*8)+1;
extern volatile bit TXB0D62             @ ((unsigned)&TXB0D6*8)+2;
extern volatile bit TXB0D63             @ ((unsigned)&TXB0D6*8)+3;
extern volatile bit TXB0D64             @ ((unsigned)&TXB0D6*8)+4;
extern volatile bit TXB0D65             @ ((unsigned)&TXB0D6*8)+5;
extern volatile bit TXB0D66             @ ((unsigned)&TXB0D6*8)+6;
extern volatile bit TXB0D67             @ ((unsigned)&TXB0D6*8)+7;
extern union {
    struct {
        volatile unsigned TXB0D60             : 1;
        volatile unsigned TXB0D61             : 1;
        volatile unsigned TXB0D62             : 1;
        volatile unsigned TXB0D63             : 1;
        volatile unsigned TXB0D64             : 1;
        volatile unsigned TXB0D65             : 1;
        volatile unsigned TXB0D66             : 1;
        volatile unsigned TXB0D67             : 1;
    };
} TXB0D6bits @ 0xF4C;

// Register: TXB0D7
extern volatile unsigned char           TXB0D7              @ 0xF4D;
// bit and bitfield definitions
extern volatile bit TXB0D70             @ ((unsigned)&TXB0D7*8)+0;
extern volatile bit TXB0D71             @ ((unsigned)&TXB0D7*8)+1;
extern volatile bit TXB0D72             @ ((unsigned)&TXB0D7*8)+2;
extern volatile bit TXB0D73             @ ((unsigned)&TXB0D7*8)+3;
extern volatile bit TXB0D74             @ ((unsigned)&TXB0D7*8)+4;
extern volatile bit TXB0D75             @ ((unsigned)&TXB0D7*8)+5;
extern volatile bit TXB0D76             @ ((unsigned)&TXB0D7*8)+6;
extern volatile bit TXB0D77             @ ((unsigned)&TXB0D7*8)+7;
extern union {
    struct {
        volatile unsigned TXB0D70             : 1;
        volatile unsigned TXB0D71             : 1;
        volatile unsigned TXB0D72             : 1;
        volatile unsigned TXB0D73             : 1;
        volatile unsigned TXB0D74             : 1;
        volatile unsigned TXB0D75             : 1;
        volatile unsigned TXB0D76             : 1;
        volatile unsigned TXB0D77             : 1;
    };
} TXB0D7bits @ 0xF4D;

// Register: CANSTATRO2
extern volatile unsigned char           CANSTATRO2          @ 0xF4E;
// bit and bitfield definitions
//extern volatile bit ICODE0             @ ((unsigned)&CANSTATRO2*8)+1;
//extern volatile bit ICODE1             @ ((unsigned)&CANSTATRO2*8)+2;
//extern volatile bit ICODE2             @ ((unsigned)&CANSTATRO2*8)+3;
//extern volatile bit OPMODE0            @ ((unsigned)&CANSTATRO2*8)+5;
//extern volatile bit OPMODE1            @ ((unsigned)&CANSTATRO2*8)+6;
//extern volatile bit OPMODE2            @ ((unsigned)&CANSTATRO2*8)+7;
extern union {
    struct {
        volatile unsigned                     : 1;
        volatile unsigned ICODE0              : 1;
        volatile unsigned ICODE1              : 1;
        volatile unsigned ICODE2              : 1;
        volatile unsigned : 1;
        volatile unsigned OPMODE0             : 1;
        volatile unsigned OPMODE1             : 1;
        volatile unsigned OPMODE2             : 1;
    };
} CANSTATRO2bits @ 0xF4E;

// Register: RXB1CON
extern volatile unsigned char           RXB1CON             @ 0xF50;
// bit and bitfield definitions
//extern volatile bit FILHIT0            @ ((unsigned)&RXB1CON*8)+0;
extern volatile bit FILHIT1             @ ((unsigned)&RXB1CON*8)+1;
extern volatile bit FILHIT2             @ ((unsigned)&RXB1CON*8)+2;
//extern volatile bit RXRTRRO            @ ((unsigned)&RXB1CON*8)+3;
//extern volatile bit RXM0               @ ((unsigned)&RXB1CON*8)+5;
//extern volatile bit RXM1               @ ((unsigned)&RXB1CON*8)+6;
//extern volatile bit RXFUL              @ ((unsigned)&RXB1CON*8)+7;
extern union {
    struct {
        volatile unsigned FILHIT0             : 1;
        volatile unsigned FILHIT1             : 1;
        volatile unsigned FILHIT2             : 1;
        volatile unsigned RXRTRRO             : 1;
        volatile unsigned                     : 1;
        volatile unsigned RXM0                : 1;
        volatile unsigned RXM1                : 1;
        volatile unsigned RXFUL               : 1;
    };
} RXB1CONbits @ 0xF50;

// Register: RXB1SIDH
extern volatile unsigned char           RXB1SIDH            @ 0xF51;
// bit and bitfield definitions
//extern volatile bit SID3               @ ((unsigned)&RXB1SIDH*8)+0;
//extern volatile bit SID4               @ ((unsigned)&RXB1SIDH*8)+1;
//extern volatile bit SID5               @ ((unsigned)&RXB1SIDH*8)+2;
//extern volatile bit SID6               @ ((unsigned)&RXB1SIDH*8)+3;
//extern volatile bit SID7               @ ((unsigned)&RXB1SIDH*8)+4;
//extern volatile bit SID8               @ ((unsigned)&RXB1SIDH*8)+5;
//extern volatile bit SID9               @ ((unsigned)&RXB1SIDH*8)+6;
//extern volatile bit SID10              @ ((unsigned)&RXB1SIDH*8)+7;
extern union {
    struct {
        volatile unsigned SID3                : 1;
        volatile unsigned SID4                : 1;
        volatile unsigned SID5                : 1;
        volatile unsigned SID6                : 1;
        volatile unsigned SID7                : 1;
        volatile unsigned SID8                : 1;
        volatile unsigned SID9                : 1;
        volatile unsigned SID10               : 1;
    };
} RXB1SIDHbits @ 0xF51;

// Register: RXB1SIDL
extern volatile unsigned char           RXB1SIDL            @ 0xF52;
// bit and bitfield definitions
//extern volatile bit EID16              @ ((unsigned)&RXB1SIDL*8)+0;
//extern volatile bit EID17              @ ((unsigned)&RXB1SIDL*8)+1;
//extern volatile bit EXID               @ ((unsigned)&RXB1SIDL*8)+3;
//extern volatile bit SRR                @ ((unsigned)&RXB1SIDL*8)+4;
//extern volatile bit SID0               @ ((unsigned)&RXB1SIDL*8)+5;
//extern volatile bit SID1               @ ((unsigned)&RXB1SIDL*8)+6;
//extern volatile bit SID2               @ ((unsigned)&RXB1SIDL*8)+7;
extern union {
    struct {
        volatile unsigned EID16               : 1;
        volatile unsigned EID17               : 1;
        volatile unsigned                     : 1;
        volatile unsigned EXID                : 1;
        volatile unsigned SRR                 : 1;
        volatile unsigned SID0                : 1;
        volatile unsigned SID1                : 1;
        volatile unsigned SID2                : 1;
    };
} RXB1SIDLbits @ 0xF52;

// Register: RXB1EIDH
extern volatile unsigned char           RXB1EIDH            @ 0xF53;
// bit and bitfield definitions
//extern volatile bit EID8               @ ((unsigned)&RXB1EIDH*8)+0;
//extern volatile bit EID9               @ ((unsigned)&RXB1EIDH*8)+1;
//extern volatile bit EID10              @ ((unsigned)&RXB1EIDH*8)+2;
//extern volatile bit EID11              @ ((unsigned)&RXB1EIDH*8)+3;
//extern volatile bit EID12              @ ((unsigned)&RXB1EIDH*8)+4;
//extern volatile bit EID13              @ ((unsigned)&RXB1EIDH*8)+5;
//extern volatile bit EID14              @ ((unsigned)&RXB1EIDH*8)+6;
//extern volatile bit EID15              @ ((unsigned)&RXB1EIDH*8)+7;
extern union {
    struct {
        volatile unsigned EID8                : 1;
        volatile unsigned EID9                : 1;
        volatile unsigned EID10               : 1;
        volatile unsigned EID11               : 1;
        volatile unsigned EID12               : 1;
        volatile unsigned EID13               : 1;
        volatile unsigned EID14               : 1;
        volatile unsigned EID15               : 1;
    };
} RXB1EIDHbits @ 0xF53;

// Register: RXB1EIDL
extern volatile unsigned char           RXB1EIDL            @ 0xF54;
// bit and bitfield definitions
//extern volatile bit EID0               @ ((unsigned)&RXB1EIDL*8)+0;
//extern volatile bit EID1               @ ((unsigned)&RXB1EIDL*8)+1;
//extern volatile bit EID2               @ ((unsigned)&RXB1EIDL*8)+2;
//extern volatile bit EID3               @ ((unsigned)&RXB1EIDL*8)+3;
//extern volatile bit EID4               @ ((unsigned)&RXB1EIDL*8)+4;
//extern volatile bit EID5               @ ((unsigned)&RXB1EIDL*8)+5;
//extern volatile bit EID6               @ ((unsigned)&RXB1EIDL*8)+6;
//extern volatile bit EID7               @ ((unsigned)&RXB1EIDL*8)+7;
extern union {
    struct {
        volatile unsigned EID0                : 1;
        volatile unsigned EID1                : 1;
        volatile unsigned EID2                : 1;
        volatile unsigned EID3                : 1;
        volatile unsigned EID4                : 1;
        volatile unsigned EID5                : 1;
        volatile unsigned EID6                : 1;
        volatile unsigned EID7                : 1;
    };
} RXB1EIDLbits @ 0xF54;

// Register: RXB1DLC
extern volatile unsigned char           RXB1DLC             @ 0xF55;
// bit and bitfield definitions
//extern volatile bit DLC0               @ ((unsigned)&RXB1DLC*8)+0;
//extern volatile bit DLC1               @ ((unsigned)&RXB1DLC*8)+1;
//extern volatile bit DLC2               @ ((unsigned)&RXB1DLC*8)+2;
//extern volatile bit DLC3               @ ((unsigned)&RXB1DLC*8)+3;
//extern volatile bit RB0                @ ((unsigned)&RXB1DLC*8)+4;
//extern volatile bit RB1                @ ((unsigned)&RXB1DLC*8)+5;
//extern volatile bit RXRTR              @ ((unsigned)&RXB1DLC*8)+6;
//extern volatile bit RESB0              @ ((unsigned)&RXB1DLC*8)+4;
//extern volatile bit RESB1              @ ((unsigned)&RXB1DLC*8)+5;
extern union {
    struct {
        volatile unsigned DLC0                : 1;
        volatile unsigned DLC1                : 1;
        volatile unsigned DLC2                : 1;
        volatile unsigned DLC3                : 1;
        volatile unsigned RB0                 : 1;
        volatile unsigned RB1                 : 1;
        volatile unsigned RXRTR               : 1;
    };
    struct {
        volatile unsigned                     : 4;
        volatile unsigned RESB0               : 1;
        volatile unsigned RESB1               : 1;
    };
} RXB1DLCbits @ 0xF55;

// Register: RXB1D0
extern volatile unsigned char           RXB1D0              @ 0xF56;
// bit and bitfield definitions
extern volatile bit RXB1D00             @ ((unsigned)&RXB1D0*8)+0;
extern volatile bit RXB1D01             @ ((unsigned)&RXB1D0*8)+1;
extern volatile bit RXB1D02             @ ((unsigned)&RXB1D0*8)+2;
extern volatile bit RXB1D03             @ ((unsigned)&RXB1D0*8)+3;
extern volatile bit RXB1D04             @ ((unsigned)&RXB1D0*8)+4;
extern volatile bit RXB1D05             @ ((unsigned)&RXB1D0*8)+5;
extern volatile bit RXB1D06             @ ((unsigned)&RXB1D0*8)+6;
extern volatile bit RXB1D07             @ ((unsigned)&RXB1D0*8)+7;
extern union {
    struct {
        volatile unsigned RXB1D00             : 1;
        volatile unsigned RXB1D01             : 1;
        volatile unsigned RXB1D02             : 1;
        volatile unsigned RXB1D03             : 1;
        volatile unsigned RXB1D04             : 1;
        volatile unsigned RXB1D05             : 1;
        volatile unsigned RXB1D06             : 1;
        volatile unsigned RXB1D07             : 1;
    };
} RXB1D0bits @ 0xF56;

// Register: RXB1D1
extern volatile unsigned char           RXB1D1              @ 0xF57;
// bit and bitfield definitions
extern volatile bit RXB1D10             @ ((unsigned)&RXB1D1*8)+0;
extern volatile bit RXB1D11             @ ((unsigned)&RXB1D1*8)+1;
extern volatile bit RXB1D12             @ ((unsigned)&RXB1D1*8)+2;
extern volatile bit RXB1D13             @ ((unsigned)&RXB1D1*8)+3;
extern volatile bit RXB1D14             @ ((unsigned)&RXB1D1*8)+4;
extern volatile bit RXB1D15             @ ((unsigned)&RXB1D1*8)+5;
extern volatile bit RXB1D16             @ ((unsigned)&RXB1D1*8)+6;
extern volatile bit RXB1D17             @ ((unsigned)&RXB1D1*8)+7;
extern union {
    struct {
        volatile unsigned RXB1D10             : 1;
        volatile unsigned RXB1D11             : 1;
        volatile unsigned RXB1D12             : 1;
        volatile unsigned RXB1D13             : 1;
        volatile unsigned RXB1D14             : 1;
        volatile unsigned RXB1D15             : 1;
        volatile unsigned RXB1D16             : 1;
        volatile unsigned RXB1D17             : 1;
    };
} RXB1D1bits @ 0xF57;

// Register: RXB1D2
extern volatile unsigned char           RXB1D2              @ 0xF58;
// bit and bitfield definitions
extern volatile bit RXB1D20             @ ((unsigned)&RXB1D2*8)+0;
extern volatile bit RXB1D21             @ ((unsigned)&RXB1D2*8)+1;
extern volatile bit RXB1D22             @ ((unsigned)&RXB1D2*8)+2;
extern volatile bit RXB1D23             @ ((unsigned)&RXB1D2*8)+3;
extern volatile bit RXB1D24             @ ((unsigned)&RXB1D2*8)+4;
extern volatile bit RXB1D25             @ ((unsigned)&RXB1D2*8)+5;
extern volatile bit RXB1D26             @ ((unsigned)&RXB1D2*8)+6;
extern volatile bit RXB1D27             @ ((unsigned)&RXB1D2*8)+7;
extern union {
    struct {
        volatile unsigned RXB1D20             : 1;
        volatile unsigned RXB1D21             : 1;
        volatile unsigned RXB1D22             : 1;
        volatile unsigned RXB1D23             : 1;
        volatile unsigned RXB1D24             : 1;
        volatile unsigned RXB1D25             : 1;
        volatile unsigned RXB1D26             : 1;
        volatile unsigned RXB1D27             : 1;
    };
} RXB1D2bits @ 0xF58;

// Register: RXB1D3
extern volatile unsigned char           RXB1D3              @ 0xF59;
// bit and bitfield definitions
extern volatile bit RXB1D30             @ ((unsigned)&RXB1D3*8)+0;
extern volatile bit RXB1D31             @ ((unsigned)&RXB1D3*8)+1;
extern volatile bit RXB1D32             @ ((unsigned)&RXB1D3*8)+2;
extern volatile bit RXB1D33             @ ((unsigned)&RXB1D3*8)+3;
extern volatile bit RXB1D34             @ ((unsigned)&RXB1D3*8)+4;
extern volatile bit RXB1D35             @ ((unsigned)&RXB1D3*8)+5;
extern volatile bit RXB1D36             @ ((unsigned)&RXB1D3*8)+6;
extern volatile bit RXB1D37             @ ((unsigned)&RXB1D3*8)+7;
extern union {
    struct {
        volatile unsigned RXB1D30             : 1;
        volatile unsigned RXB1D31             : 1;
        volatile unsigned RXB1D32             : 1;
        volatile unsigned RXB1D33             : 1;
        volatile unsigned RXB1D34             : 1;
        volatile unsigned RXB1D35             : 1;
        volatile unsigned RXB1D36             : 1;
        volatile unsigned RXB1D37             : 1;
    };
} RXB1D3bits @ 0xF59;

// Register: RXB1D4
extern volatile unsigned char           RXB1D4              @ 0xF5A;
// bit and bitfield definitions
extern volatile bit RXB1D40             @ ((unsigned)&RXB1D4*8)+0;
extern volatile bit RXB1D41             @ ((unsigned)&RXB1D4*8)+1;
extern volatile bit RXB1D42             @ ((unsigned)&RXB1D4*8)+2;
extern volatile bit RXB1D43             @ ((unsigned)&RXB1D4*8)+3;
extern volatile bit RXB1D44             @ ((unsigned)&RXB1D4*8)+4;
extern volatile bit RXB1D45             @ ((unsigned)&RXB1D4*8)+5;
extern volatile bit RXB1D46             @ ((unsigned)&RXB1D4*8)+6;
extern volatile bit RXB1D47             @ ((unsigned)&RXB1D4*8)+7;
extern union {
    struct {
        volatile unsigned RXB1D40             : 1;
        volatile unsigned RXB1D41             : 1;
        volatile unsigned RXB1D42             : 1;
        volatile unsigned RXB1D43             : 1;
        volatile unsigned RXB1D44             : 1;
        volatile unsigned RXB1D45             : 1;
        volatile unsigned RXB1D46             : 1;
        volatile unsigned RXB1D47             : 1;
    };
} RXB1D4bits @ 0xF5A;

// Register: RXB1D5
extern volatile unsigned char           RXB1D5              @ 0xF5B;
// bit and bitfield definitions
extern volatile bit RXB1D50             @ ((unsigned)&RXB1D5*8)+0;
extern volatile bit RXB1D51             @ ((unsigned)&RXB1D5*8)+1;
extern volatile bit RXB1D52             @ ((unsigned)&RXB1D5*8)+2;
extern volatile bit RXB1D53             @ ((unsigned)&RXB1D5*8)+3;
extern volatile bit RXB1D54             @ ((unsigned)&RXB1D5*8)+4;
extern volatile bit RXB1D55             @ ((unsigned)&RXB1D5*8)+5;
extern volatile bit RXB1D56             @ ((unsigned)&RXB1D5*8)+6;
extern volatile bit RXB1D57             @ ((unsigned)&RXB1D5*8)+7;
extern union {
    struct {
        volatile unsigned RXB1D50             : 1;
        volatile unsigned RXB1D51             : 1;
        volatile unsigned RXB1D52             : 1;
        volatile unsigned RXB1D53             : 1;
        volatile unsigned RXB1D54             : 1;
        volatile unsigned RXB1D55             : 1;
        volatile unsigned RXB1D56             : 1;
        volatile unsigned RXB1D57             : 1;
    };
} RXB1D5bits @ 0xF5B;

// Register: RXB1D6
extern volatile unsigned char           RXB1D6              @ 0xF5C;
// bit and bitfield definitions
extern volatile bit RXB1D60             @ ((unsigned)&RXB1D6*8)+0;
extern volatile bit RXB1D61             @ ((unsigned)&RXB1D6*8)+1;
extern volatile bit RXB1D62             @ ((unsigned)&RXB1D6*8)+2;
extern volatile bit RXB1D63             @ ((unsigned)&RXB1D6*8)+3;
extern volatile bit RXB1D64             @ ((unsigned)&RXB1D6*8)+4;
extern volatile bit RXB1D65             @ ((unsigned)&RXB1D6*8)+5;
extern volatile bit RXB1D66             @ ((unsigned)&RXB1D6*8)+6;
extern volatile bit RXB1D67             @ ((unsigned)&RXB1D6*8)+7;
extern union {
    struct {
        volatile unsigned RXB1D60             : 1;
        volatile unsigned RXB1D61             : 1;
        volatile unsigned RXB1D62             : 1;
        volatile unsigned RXB1D63             : 1;
        volatile unsigned RXB1D64             : 1;
        volatile unsigned RXB1D65             : 1;
        volatile unsigned RXB1D66             : 1;
        volatile unsigned RXB1D67             : 1;
    };
} RXB1D6bits @ 0xF5C;

// Register: RXB1D7
extern volatile unsigned char           RXB1D7              @ 0xF5D;
// bit and bitfield definitions
extern volatile bit RXB1D70             @ ((unsigned)&RXB1D7*8)+0;
extern volatile bit RXB1D71             @ ((unsigned)&RXB1D7*8)+1;
extern volatile bit RXB1D72             @ ((unsigned)&RXB1D7*8)+2;
extern volatile bit RXB1D73             @ ((unsigned)&RXB1D7*8)+3;
extern volatile bit RXB1D74             @ ((unsigned)&RXB1D7*8)+4;
extern volatile bit RXB1D75             @ ((unsigned)&RXB1D7*8)+5;
extern volatile bit RXB1D76             @ ((unsigned)&RXB1D7*8)+6;
extern volatile bit RXB1D77             @ ((unsigned)&RXB1D7*8)+7;
extern union {
    struct {
        volatile unsigned RXB1D70             : 1;
        volatile unsigned RXB1D71             : 1;
        volatile unsigned RXB1D72             : 1;
        volatile unsigned RXB1D73             : 1;
        volatile unsigned RXB1D74             : 1;
        volatile unsigned RXB1D75             : 1;
        volatile unsigned RXB1D76             : 1;
        volatile unsigned RXB1D77             : 1;
    };
} RXB1D7bits @ 0xF5D;

// Register: CANSTATRO1
extern volatile unsigned char           CANSTATRO1          @ 0xF5E;
// bit and bitfield definitions
//extern volatile bit ICODE0             @ ((unsigned)&CANSTATRO1*8)+1;
//extern volatile bit ICODE1             @ ((unsigned)&CANSTATRO1*8)+2;
//extern volatile bit ICODE2             @ ((unsigned)&CANSTATRO1*8)+3;
//extern volatile bit OPMODE0            @ ((unsigned)&CANSTATRO1*8)+5;
//extern volatile bit OPMODE1            @ ((unsigned)&CANSTATRO1*8)+6;
//extern volatile bit OPMODE2            @ ((unsigned)&CANSTATRO1*8)+7;
extern union {
    struct {
        volatile unsigned                     : 1;
        volatile unsigned ICODE0              : 1;
        volatile unsigned ICODE1              : 1;
        volatile unsigned ICODE2              : 1;
        volatile unsigned : 1;
        volatile unsigned OPMODE0             : 1;
        volatile unsigned OPMODE1             : 1;
        volatile unsigned OPMODE2             : 1;
    };
} CANSTATRO1bits @ 0xF5E;

//
// Special function register definitions: Bank 0xf
//

// Register: RXB0CON
extern volatile unsigned char           RXB0CON             @ 0xF60;
// bit and bitfield definitions
//extern volatile bit FILHIT0            @ ((unsigned)&RXB0CON*8)+0;
extern volatile bit JTOFF               @ ((unsigned)&RXB0CON*8)+1;
extern volatile bit RXB0DBEN            @ ((unsigned)&RXB0CON*8)+2;
//extern volatile bit RXRTRRO            @ ((unsigned)&RXB0CON*8)+3;
//extern volatile bit RXM0               @ ((unsigned)&RXB0CON*8)+5;
//extern volatile bit RXM1               @ ((unsigned)&RXB0CON*8)+6;
//extern volatile bit RXFUL              @ ((unsigned)&RXB0CON*8)+7;
extern union {
    struct {
        volatile unsigned FILHIT0             : 1;
        volatile unsigned JTOFF               : 1;
        volatile unsigned RXB0DBEN            : 1;
        volatile unsigned RXRTRRO             : 1;
        volatile unsigned                     : 1;
        volatile unsigned RXM0                : 1;
        volatile unsigned RXM1                : 1;
        volatile unsigned RXFUL               : 1;
    };
    struct {
        volatile unsigned : 5;
    };
} RXB0CONbits @ 0xF60;

// Register: RXB0SIDH
extern volatile unsigned char           RXB0SIDH            @ 0xF61;
// bit and bitfield definitions
//extern volatile bit SID3               @ ((unsigned)&RXB0SIDH*8)+0;
//extern volatile bit SID4               @ ((unsigned)&RXB0SIDH*8)+1;
//extern volatile bit SID5               @ ((unsigned)&RXB0SIDH*8)+2;
//extern volatile bit SID6               @ ((unsigned)&RXB0SIDH*8)+3;
//extern volatile bit SID7               @ ((unsigned)&RXB0SIDH*8)+4;
//extern volatile bit SID8               @ ((unsigned)&RXB0SIDH*8)+5;
//extern volatile bit SID9               @ ((unsigned)&RXB0SIDH*8)+6;
//extern volatile bit SID10              @ ((unsigned)&RXB0SIDH*8)+7;
extern union {
    struct {
        volatile unsigned SID3                : 1;
        volatile unsigned SID4                : 1;
        volatile unsigned SID5                : 1;
        volatile unsigned SID6                : 1;
        volatile unsigned SID7                : 1;
        volatile unsigned SID8                : 1;
        volatile unsigned SID9                : 1;
        volatile unsigned SID10               : 1;
    };
} RXB0SIDHbits @ 0xF61;

// Register: RXB0SIDL
extern volatile unsigned char           RXB0SIDL            @ 0xF62;
// bit and bitfield definitions
//extern volatile bit EID16              @ ((unsigned)&RXB0SIDL*8)+0;
//extern volatile bit EID17              @ ((unsigned)&RXB0SIDL*8)+1;
//extern volatile bit EXID               @ ((unsigned)&RXB0SIDL*8)+3;
//extern volatile bit SRR                @ ((unsigned)&RXB0SIDL*8)+4;
//extern volatile bit SID0               @ ((unsigned)&RXB0SIDL*8)+5;
//extern volatile bit SID1               @ ((unsigned)&RXB0SIDL*8)+6;
//extern volatile bit SID2               @ ((unsigned)&RXB0SIDL*8)+7;
extern union {
    struct {
        volatile unsigned EID16               : 1;
        volatile unsigned EID17               : 1;
        volatile unsigned                     : 1;
        volatile unsigned EXID                : 1;
        volatile unsigned SRR                 : 1;
        volatile unsigned SID0                : 1;
        volatile unsigned SID1                : 1;
        volatile unsigned SID2                : 1;
    };
} RXB0SIDLbits @ 0xF62;

// Register: RXB0EIDH
extern volatile unsigned char           RXB0EIDH            @ 0xF63;
// bit and bitfield definitions
//extern volatile bit EID8               @ ((unsigned)&RXB0EIDH*8)+0;
//extern volatile bit EID9               @ ((unsigned)&RXB0EIDH*8)+1;
//extern volatile bit EID10              @ ((unsigned)&RXB0EIDH*8)+2;
//extern volatile bit EID11              @ ((unsigned)&RXB0EIDH*8)+3;
//extern volatile bit EID12              @ ((unsigned)&RXB0EIDH*8)+4;
//extern volatile bit EID13              @ ((unsigned)&RXB0EIDH*8)+5;
//extern volatile bit EID14              @ ((unsigned)&RXB0EIDH*8)+6;
//extern volatile bit EID15              @ ((unsigned)&RXB0EIDH*8)+7;
extern union {
    struct {
        volatile unsigned EID8                : 1;
        volatile unsigned EID9                : 1;
        volatile unsigned EID10               : 1;
        volatile unsigned EID11               : 1;
        volatile unsigned EID12               : 1;
        volatile unsigned EID13               : 1;
        volatile unsigned EID14               : 1;
        volatile unsigned EID15               : 1;
    };
} RXB0EIDHbits @ 0xF63;

// Register: RXB0EIDL
extern volatile unsigned char           RXB0EIDL            @ 0xF64;
// bit and bitfield definitions
//extern volatile bit EID0               @ ((unsigned)&RXB0EIDL*8)+0;
//extern volatile bit EID1               @ ((unsigned)&RXB0EIDL*8)+1;
//extern volatile bit EID2               @ ((unsigned)&RXB0EIDL*8)+2;
//extern volatile bit EID3               @ ((unsigned)&RXB0EIDL*8)+3;
//extern volatile bit EID4               @ ((unsigned)&RXB0EIDL*8)+4;
//extern volatile bit EID5               @ ((unsigned)&RXB0EIDL*8)+5;
//extern volatile bit EID6               @ ((unsigned)&RXB0EIDL*8)+6;
//extern volatile bit EID7               @ ((unsigned)&RXB0EIDL*8)+7;
extern union {
    struct {
        volatile unsigned EID0                : 1;
        volatile unsigned EID1                : 1;
        volatile unsigned EID2                : 1;
        volatile unsigned EID3                : 1;
        volatile unsigned EID4                : 1;
        volatile unsigned EID5                : 1;
        volatile unsigned EID6                : 1;
        volatile unsigned EID7                : 1;
    };
} RXB0EIDLbits @ 0xF64;

// Register: RXB0DLC
extern volatile unsigned char           RXB0DLC             @ 0xF65;
// bit and bitfield definitions
//extern volatile bit DLC0               @ ((unsigned)&RXB0DLC*8)+0;
//extern volatile bit DLC1               @ ((unsigned)&RXB0DLC*8)+1;
//extern volatile bit DLC2               @ ((unsigned)&RXB0DLC*8)+2;
//extern volatile bit DLC3               @ ((unsigned)&RXB0DLC*8)+3;
//extern volatile bit RB0                @ ((unsigned)&RXB0DLC*8)+4;
//extern volatile bit RB1                @ ((unsigned)&RXB0DLC*8)+5;
//extern volatile bit RXRTR              @ ((unsigned)&RXB0DLC*8)+6;
//extern volatile bit RESB0              @ ((unsigned)&RXB0DLC*8)+4;
//extern volatile bit RESB1              @ ((unsigned)&RXB0DLC*8)+5;
extern union {
    struct {
        volatile unsigned DLC0                : 1;
        volatile unsigned DLC1                : 1;
        volatile unsigned DLC2                : 1;
        volatile unsigned DLC3                : 1;
        volatile unsigned RB0                 : 1;
        volatile unsigned RB1                 : 1;
        volatile unsigned RXRTR               : 1;
    };
    struct {
        volatile unsigned                     : 4;
        volatile unsigned RESB0               : 1;
        volatile unsigned RESB1               : 1;
    };
} RXB0DLCbits @ 0xF65;

// Register: RXB0D0
extern volatile unsigned char           RXB0D0              @ 0xF66;
// bit and bitfield definitions
extern volatile bit RXB0D00             @ ((unsigned)&RXB0D0*8)+0;
extern volatile bit RXB0D01             @ ((unsigned)&RXB0D0*8)+1;
extern volatile bit RXB0D02             @ ((unsigned)&RXB0D0*8)+2;
extern volatile bit RXB0D03             @ ((unsigned)&RXB0D0*8)+3;
extern volatile bit RXB0D04             @ ((unsigned)&RXB0D0*8)+4;
extern volatile bit RXB0D05             @ ((unsigned)&RXB0D0*8)+5;
extern volatile bit RXB0D06             @ ((unsigned)&RXB0D0*8)+6;
extern volatile bit RXB0D07             @ ((unsigned)&RXB0D0*8)+7;
extern volatile bit RB0D00              @ ((unsigned)&RXB0D0*8)+0;
extern volatile bit RB0D01              @ ((unsigned)&RXB0D0*8)+1;
extern volatile bit RB0D02              @ ((unsigned)&RXB0D0*8)+2;
extern volatile bit RB0D03              @ ((unsigned)&RXB0D0*8)+3;
extern volatile bit RB0D04              @ ((unsigned)&RXB0D0*8)+4;
extern volatile bit RB0D05              @ ((unsigned)&RXB0D0*8)+5;
extern volatile bit RB0D06              @ ((unsigned)&RXB0D0*8)+6;
extern volatile bit RB0D07              @ ((unsigned)&RXB0D0*8)+7;
extern union {
    struct {
        volatile unsigned RXB0D00             : 1;
        volatile unsigned RXB0D01             : 1;
        volatile unsigned RXB0D02             : 1;
        volatile unsigned RXB0D03             : 1;
        volatile unsigned RXB0D04             : 1;
        volatile unsigned RXB0D05             : 1;
        volatile unsigned RXB0D06             : 1;
        volatile unsigned RXB0D07             : 1;
    };
    struct {
        volatile unsigned RB0D00              : 1;
        volatile unsigned RB0D01              : 1;
        volatile unsigned RB0D02              : 1;
        volatile unsigned RB0D03              : 1;
        volatile unsigned RB0D04              : 1;
        volatile unsigned RB0D05              : 1;
        volatile unsigned RB0D06              : 1;
        volatile unsigned RB0D07              : 1;
    };
} RXB0D0bits @ 0xF66;

// Register: RXB0D1
extern volatile unsigned char           RXB0D1              @ 0xF67;
// bit and bitfield definitions
extern volatile bit RXB0D10             @ ((unsigned)&RXB0D1*8)+0;
extern volatile bit RXB0D11             @ ((unsigned)&RXB0D1*8)+1;
extern volatile bit RXB0D12             @ ((unsigned)&RXB0D1*8)+2;
extern volatile bit RXB0D13             @ ((unsigned)&RXB0D1*8)+3;
extern volatile bit RXB0D14             @ ((unsigned)&RXB0D1*8)+4;
extern volatile bit RXB0D15             @ ((unsigned)&RXB0D1*8)+5;
extern volatile bit RXB0D16             @ ((unsigned)&RXB0D1*8)+6;
extern volatile bit RXB0D17             @ ((unsigned)&RXB0D1*8)+7;
extern volatile bit RB0D10              @ ((unsigned)&RXB0D1*8)+0;
extern volatile bit RB0D11              @ ((unsigned)&RXB0D1*8)+1;
extern volatile bit RB0D12              @ ((unsigned)&RXB0D1*8)+2;
extern volatile bit RB0D13              @ ((unsigned)&RXB0D1*8)+3;
extern volatile bit RB0D14              @ ((unsigned)&RXB0D1*8)+4;
extern volatile bit RB0D15              @ ((unsigned)&RXB0D1*8)+5;
extern volatile bit RB0D16              @ ((unsigned)&RXB0D1*8)+6;
extern volatile bit RB0D17              @ ((unsigned)&RXB0D1*8)+7;
extern union {
    struct {
        volatile unsigned RXB0D10             : 1;
        volatile unsigned RXB0D11             : 1;
        volatile unsigned RXB0D12             : 1;
        volatile unsigned RXB0D13             : 1;
        volatile unsigned RXB0D14             : 1;
        volatile unsigned RXB0D15             : 1;
        volatile unsigned RXB0D16             : 1;
        volatile unsigned RXB0D17             : 1;
    };
    struct {
        volatile unsigned RB0D10              : 1;
        volatile unsigned RB0D11              : 1;
        volatile unsigned RB0D12              : 1;
        volatile unsigned RB0D13              : 1;
        volatile unsigned RB0D14              : 1;
        volatile unsigned RB0D15              : 1;
        volatile unsigned RB0D16              : 1;
        volatile unsigned RB0D17              : 1;
    };
} RXB0D1bits @ 0xF67;

// Register: RXB0D2
extern volatile unsigned char           RXB0D2              @ 0xF68;
// bit and bitfield definitions
extern volatile bit RXB0D20             @ ((unsigned)&RXB0D2*8)+0;
extern volatile bit RXB0D21             @ ((unsigned)&RXB0D2*8)+1;
extern volatile bit RXB0D22             @ ((unsigned)&RXB0D2*8)+2;
extern volatile bit RXB0D23             @ ((unsigned)&RXB0D2*8)+3;
extern volatile bit RXB0D24             @ ((unsigned)&RXB0D2*8)+4;
extern volatile bit RXB0D25             @ ((unsigned)&RXB0D2*8)+5;
extern volatile bit RXB0D26             @ ((unsigned)&RXB0D2*8)+6;
extern volatile bit RXB0D27             @ ((unsigned)&RXB0D2*8)+7;
extern volatile bit RB0D20              @ ((unsigned)&RXB0D2*8)+0;
extern volatile bit RB0D21              @ ((unsigned)&RXB0D2*8)+1;
extern volatile bit RB0D22              @ ((unsigned)&RXB0D2*8)+2;
extern volatile bit RB0D23              @ ((unsigned)&RXB0D2*8)+3;
extern volatile bit RB0D24              @ ((unsigned)&RXB0D2*8)+4;
extern volatile bit RB0D25              @ ((unsigned)&RXB0D2*8)+5;
extern volatile bit RB0D26              @ ((unsigned)&RXB0D2*8)+6;
extern volatile bit RB0D27              @ ((unsigned)&RXB0D2*8)+7;
extern union {
    struct {
        volatile unsigned RXB0D20             : 1;
        volatile unsigned RXB0D21             : 1;
        volatile unsigned RXB0D22             : 1;
        volatile unsigned RXB0D23             : 1;
        volatile unsigned RXB0D24             : 1;
        volatile unsigned RXB0D25             : 1;
        volatile unsigned RXB0D26             : 1;
        volatile unsigned RXB0D27             : 1;
    };
    struct {
        volatile unsigned RB0D20              : 1;
        volatile unsigned RB0D21              : 1;
        volatile unsigned RB0D22              : 1;
        volatile unsigned RB0D23              : 1;
        volatile unsigned RB0D24              : 1;
        volatile unsigned RB0D25              : 1;
        volatile unsigned RB0D26              : 1;
        volatile unsigned RB0D27              : 1;
    };
} RXB0D2bits @ 0xF68;

// Register: RXB0D3
extern volatile unsigned char           RXB0D3              @ 0xF69;
// bit and bitfield definitions
extern volatile bit RXB0D30             @ ((unsigned)&RXB0D3*8)+0;
extern volatile bit RXB0D31             @ ((unsigned)&RXB0D3*8)+1;
extern volatile bit RXB0D32             @ ((unsigned)&RXB0D3*8)+2;
extern volatile bit RXB0D33             @ ((unsigned)&RXB0D3*8)+3;
extern volatile bit RXB0D34             @ ((unsigned)&RXB0D3*8)+4;
extern volatile bit RXB0D35             @ ((unsigned)&RXB0D3*8)+5;
extern volatile bit RXB0D36             @ ((unsigned)&RXB0D3*8)+6;
extern volatile bit RXB0D37             @ ((unsigned)&RXB0D3*8)+7;
extern volatile bit RB0D30              @ ((unsigned)&RXB0D3*8)+0;
extern volatile bit RB0D31              @ ((unsigned)&RXB0D3*8)+1;
extern volatile bit RB0D32              @ ((unsigned)&RXB0D3*8)+2;
extern volatile bit RB0D33              @ ((unsigned)&RXB0D3*8)+3;
extern volatile bit RB0D34              @ ((unsigned)&RXB0D3*8)+4;
extern volatile bit RB0D35              @ ((unsigned)&RXB0D3*8)+5;
extern volatile bit RB0D36              @ ((unsigned)&RXB0D3*8)+6;
extern volatile bit RB0D37              @ ((unsigned)&RXB0D3*8)+7;
extern union {
    struct {
        volatile unsigned RXB0D30             : 1;
        volatile unsigned RXB0D31             : 1;
        volatile unsigned RXB0D32             : 1;
        volatile unsigned RXB0D33             : 1;
        volatile unsigned RXB0D34             : 1;
        volatile unsigned RXB0D35             : 1;
        volatile unsigned RXB0D36             : 1;
        volatile unsigned RXB0D37             : 1;
    };
    struct {
        volatile unsigned RB0D30              : 1;
        volatile unsigned RB0D31              : 1;
        volatile unsigned RB0D32              : 1;
        volatile unsigned RB0D33              : 1;
        volatile unsigned RB0D34              : 1;
        volatile unsigned RB0D35              : 1;
        volatile unsigned RB0D36              : 1;
        volatile unsigned RB0D37              : 1;
    };
} RXB0D3bits @ 0xF69;

// Register: RXB0D4
extern volatile unsigned char           RXB0D4              @ 0xF6A;
// bit and bitfield definitions
extern volatile bit RXB0D40             @ ((unsigned)&RXB0D4*8)+0;
extern volatile bit RXB0D41             @ ((unsigned)&RXB0D4*8)+1;
extern volatile bit RXB0D42             @ ((unsigned)&RXB0D4*8)+2;
extern volatile bit RXB0D43             @ ((unsigned)&RXB0D4*8)+3;
extern volatile bit RXB0D44             @ ((unsigned)&RXB0D4*8)+4;
extern volatile bit RXB0D45             @ ((unsigned)&RXB0D4*8)+5;
extern volatile bit RXB0D46             @ ((unsigned)&RXB0D4*8)+6;
extern volatile bit RXB0D47             @ ((unsigned)&RXB0D4*8)+7;
extern volatile bit RB0D40              @ ((unsigned)&RXB0D4*8)+0;
extern volatile bit RB0D41              @ ((unsigned)&RXB0D4*8)+1;
extern volatile bit RB0D42              @ ((unsigned)&RXB0D4*8)+2;
extern volatile bit RB0D43              @ ((unsigned)&RXB0D4*8)+3;
extern volatile bit RB0D44              @ ((unsigned)&RXB0D4*8)+4;
extern volatile bit RB0D45              @ ((unsigned)&RXB0D4*8)+5;
extern volatile bit RB0D46              @ ((unsigned)&RXB0D4*8)+6;
extern volatile bit RB0D47              @ ((unsigned)&RXB0D4*8)+7;
extern union {
    struct {
        volatile unsigned RXB0D40             : 1;
        volatile unsigned RXB0D41             : 1;
        volatile unsigned RXB0D42             : 1;
        volatile unsigned RXB0D43             : 1;
        volatile unsigned RXB0D44             : 1;
        volatile unsigned RXB0D45             : 1;
        volatile unsigned RXB0D46             : 1;
        volatile unsigned RXB0D47             : 1;
    };
    struct {
        volatile unsigned RB0D40              : 1;
        volatile unsigned RB0D41              : 1;
        volatile unsigned RB0D42              : 1;
        volatile unsigned RB0D43              : 1;
        volatile unsigned RB0D44              : 1;
        volatile unsigned RB0D45              : 1;
        volatile unsigned RB0D46              : 1;
        volatile unsigned RB0D47              : 1;
    };
} RXB0D4bits @ 0xF6A;

// Register: RXB0D5
extern volatile unsigned char           RXB0D5              @ 0xF6B;
// bit and bitfield definitions
extern volatile bit RXB0D50             @ ((unsigned)&RXB0D5*8)+0;
extern volatile bit RXB0D51             @ ((unsigned)&RXB0D5*8)+1;
extern volatile bit RXB0D52             @ ((unsigned)&RXB0D5*8)+2;
extern volatile bit RXB0D53             @ ((unsigned)&RXB0D5*8)+3;
extern volatile bit RXB0D54             @ ((unsigned)&RXB0D5*8)+4;
extern volatile bit RXB0D55             @ ((unsigned)&RXB0D5*8)+5;
extern volatile bit RXB0D56             @ ((unsigned)&RXB0D5*8)+6;
extern volatile bit RXB0D57             @ ((unsigned)&RXB0D5*8)+7;
extern volatile bit RB0D50              @ ((unsigned)&RXB0D5*8)+0;
extern volatile bit RB0D51              @ ((unsigned)&RXB0D5*8)+1;
extern volatile bit RB0D52              @ ((unsigned)&RXB0D5*8)+2;
extern volatile bit RB0D53              @ ((unsigned)&RXB0D5*8)+3;
extern volatile bit RB0D54              @ ((unsigned)&RXB0D5*8)+4;
extern volatile bit RB0D55              @ ((unsigned)&RXB0D5*8)+5;
extern volatile bit RB0D56              @ ((unsigned)&RXB0D5*8)+6;
extern volatile bit RB0D57              @ ((unsigned)&RXB0D5*8)+7;
extern union {
    struct {
        volatile unsigned RXB0D50             : 1;
        volatile unsigned RXB0D51             : 1;
        volatile unsigned RXB0D52             : 1;
        volatile unsigned RXB0D53             : 1;
        volatile unsigned RXB0D54             : 1;
        volatile unsigned RXB0D55             : 1;
        volatile unsigned RXB0D56             : 1;
        volatile unsigned RXB0D57             : 1;
    };
    struct {
        volatile unsigned RB0D50              : 1;
        volatile unsigned RB0D51              : 1;
        volatile unsigned RB0D52              : 1;
        volatile unsigned RB0D53              : 1;
        volatile unsigned RB0D54              : 1;
        volatile unsigned RB0D55              : 1;
        volatile unsigned RB0D56              : 1;
        volatile unsigned RB0D57              : 1;
    };
} RXB0D5bits @ 0xF6B;

// Register: RXB0D6
extern volatile unsigned char           RXB0D6              @ 0xF6C;
// bit and bitfield definitions
extern volatile bit RXB0D60             @ ((unsigned)&RXB0D6*8)+0;
extern volatile bit RXB0D61             @ ((unsigned)&RXB0D6*8)+1;
extern volatile bit RXB0D62             @ ((unsigned)&RXB0D6*8)+2;
extern volatile bit RXB0D63             @ ((unsigned)&RXB0D6*8)+3;
extern volatile bit RXB0D64             @ ((unsigned)&RXB0D6*8)+4;
extern volatile bit RXB0D65             @ ((unsigned)&RXB0D6*8)+5;
extern volatile bit RXB0D66             @ ((unsigned)&RXB0D6*8)+6;
extern volatile bit RXB0D67             @ ((unsigned)&RXB0D6*8)+7;
extern volatile bit RB0D60              @ ((unsigned)&RXB0D6*8)+0;
extern volatile bit RB0D61              @ ((unsigned)&RXB0D6*8)+1;
extern volatile bit RB0D62              @ ((unsigned)&RXB0D6*8)+2;
extern volatile bit RB0D63              @ ((unsigned)&RXB0D6*8)+3;
extern volatile bit RB0D64              @ ((unsigned)&RXB0D6*8)+4;
extern volatile bit RB0D65              @ ((unsigned)&RXB0D6*8)+5;
extern volatile bit RB0D66              @ ((unsigned)&RXB0D6*8)+6;
extern volatile bit RB0D67              @ ((unsigned)&RXB0D6*8)+7;
extern union {
    struct {
        volatile unsigned RXB0D60             : 1;
        volatile unsigned RXB0D61             : 1;
        volatile unsigned RXB0D62             : 1;
        volatile unsigned RXB0D63             : 1;
        volatile unsigned RXB0D64             : 1;
        volatile unsigned RXB0D65             : 1;
        volatile unsigned RXB0D66             : 1;
        volatile unsigned RXB0D67             : 1;
    };
    struct {
        volatile unsigned RB0D60              : 1;
        volatile unsigned RB0D61              : 1;
        volatile unsigned RB0D62              : 1;
        volatile unsigned RB0D63              : 1;
        volatile unsigned RB0D64              : 1;
        volatile unsigned RB0D65              : 1;
        volatile unsigned RB0D66              : 1;
        volatile unsigned RB0D67              : 1;
    };
} RXB0D6bits @ 0xF6C;

// Register: RXB0D7
extern volatile unsigned char           RXB0D7              @ 0xF6D;
// bit and bitfield definitions
extern volatile bit RXB0D70             @ ((unsigned)&RXB0D7*8)+0;
extern volatile bit RXB0D71             @ ((unsigned)&RXB0D7*8)+1;
extern volatile bit RXB0D72             @ ((unsigned)&RXB0D7*8)+2;
extern volatile bit RXB0D73             @ ((unsigned)&RXB0D7*8)+3;
extern volatile bit RXB0D74             @ ((unsigned)&RXB0D7*8)+4;
extern volatile bit RXB0D75             @ ((unsigned)&RXB0D7*8)+5;
extern volatile bit RXB0D76             @ ((unsigned)&RXB0D7*8)+6;
extern volatile bit RXB0D77             @ ((unsigned)&RXB0D7*8)+7;
extern volatile bit RB0D70              @ ((unsigned)&RXB0D7*8)+0;
extern volatile bit RB0D71              @ ((unsigned)&RXB0D7*8)+1;
extern volatile bit RB0D72              @ ((unsigned)&RXB0D7*8)+2;
extern volatile bit RB0D73              @ ((unsigned)&RXB0D7*8)+3;
extern volatile bit RB0D74              @ ((unsigned)&RXB0D7*8)+4;
extern volatile bit RB0D75              @ ((unsigned)&RXB0D7*8)+5;
extern volatile bit RB0D76              @ ((unsigned)&RXB0D7*8)+6;
extern volatile bit RB0D77              @ ((unsigned)&RXB0D7*8)+7;
extern union {
    struct {
        volatile unsigned RXB0D70             : 1;
        volatile unsigned RXB0D71             : 1;
        volatile unsigned RXB0D72             : 1;
        volatile unsigned RXB0D73             : 1;
        volatile unsigned RXB0D74             : 1;
        volatile unsigned RXB0D75             : 1;
        volatile unsigned RXB0D76             : 1;
        volatile unsigned RXB0D77             : 1;
    };
    struct {
        volatile unsigned RB0D70              : 1;
        volatile unsigned RB0D71              : 1;
        volatile unsigned RB0D72              : 1;
        volatile unsigned RB0D73              : 1;
        volatile unsigned RB0D74              : 1;
        volatile unsigned RB0D75              : 1;
        volatile unsigned RB0D76              : 1;
        volatile unsigned RB0D77              : 1;
    };
} RXB0D7bits @ 0xF6D;

// Register: CANSTAT
extern volatile unsigned char           CANSTAT             @ 0xF6E;
// bit and bitfield definitions
//extern volatile bit ICODE0             @ ((unsigned)&CANSTAT*8)+1;
//extern volatile bit ICODE1             @ ((unsigned)&CANSTAT*8)+2;
//extern volatile bit ICODE2             @ ((unsigned)&CANSTAT*8)+3;
//extern volatile bit OPMODE0            @ ((unsigned)&CANSTAT*8)+5;
//extern volatile bit OPMODE1            @ ((unsigned)&CANSTAT*8)+6;
//extern volatile bit OPMODE2            @ ((unsigned)&CANSTAT*8)+7;
extern union {
    struct {
        volatile unsigned                     : 1;
        volatile unsigned ICODE0              : 1;
        volatile unsigned ICODE1              : 1;
        volatile unsigned ICODE2              : 1;
        volatile unsigned : 1;
        volatile unsigned OPMODE0             : 1;
        volatile unsigned OPMODE1             : 1;
        volatile unsigned OPMODE2             : 1;
    };
} CANSTATbits @ 0xF6E;

// Register: CANCON
extern volatile unsigned char           CANCON              @ 0xF6F;
// bit and bitfield definitions
extern volatile bit WIN0                @ ((unsigned)&CANCON*8)+1;
extern volatile bit WIN1                @ ((unsigned)&CANCON*8)+2;
extern volatile bit WIN2                @ ((unsigned)&CANCON*8)+3;
extern volatile bit ABAT                @ ((unsigned)&CANCON*8)+4;
extern volatile bit REQOP0              @ ((unsigned)&CANCON*8)+5;
extern volatile bit REQOP1              @ ((unsigned)&CANCON*8)+6;
extern volatile bit REQOP2              @ ((unsigned)&CANCON*8)+7;
extern union {
    struct {
        volatile unsigned                     : 1;
        volatile unsigned WIN0                : 1;
        volatile unsigned WIN1                : 1;
        volatile unsigned WIN2                : 1;
        volatile unsigned ABAT                : 1;
        volatile unsigned REQOP0              : 1;
        volatile unsigned REQOP1              : 1;
        volatile unsigned REQOP2              : 1;
    };
} CANCONbits @ 0xF6F;

// Register: BRGCON1
extern volatile unsigned char           BRGCON1             @ 0xF70;
// bit and bitfield definitions
extern volatile bit BRP0                @ ((unsigned)&BRGCON1*8)+0;
extern volatile bit BRP1                @ ((unsigned)&BRGCON1*8)+1;
extern volatile bit BRP2                @ ((unsigned)&BRGCON1*8)+2;
extern volatile bit BRP3                @ ((unsigned)&BRGCON1*8)+3;
extern volatile bit BRP4                @ ((unsigned)&BRGCON1*8)+4;
extern volatile bit BRP5                @ ((unsigned)&BRGCON1*8)+5;
extern volatile bit SJW0                @ ((unsigned)&BRGCON1*8)+6;
extern volatile bit SJW1                @ ((unsigned)&BRGCON1*8)+7;
extern union {
    struct {
        volatile unsigned BRP0                : 1;
        volatile unsigned BRP1                : 1;
        volatile unsigned BRP2                : 1;
        volatile unsigned BRP3                : 1;
        volatile unsigned BRP4                : 1;
        volatile unsigned BRP5                : 1;
        volatile unsigned SJW0                : 1;
        volatile unsigned SJW1                : 1;
    };
} BRGCON1bits @ 0xF70;

// Register: BRGCON2
extern volatile unsigned char           BRGCON2             @ 0xF71;
// bit and bitfield definitions
extern volatile bit PRSEG0              @ ((unsigned)&BRGCON2*8)+0;
extern volatile bit PRSEG1              @ ((unsigned)&BRGCON2*8)+1;
extern volatile bit PRSEG2              @ ((unsigned)&BRGCON2*8)+2;
extern volatile bit SEG1PH0             @ ((unsigned)&BRGCON2*8)+3;
extern volatile bit SEG1PH1             @ ((unsigned)&BRGCON2*8)+4;
extern volatile bit SEG1PH2             @ ((unsigned)&BRGCON2*8)+5;
extern volatile bit SAM                 @ ((unsigned)&BRGCON2*8)+6;
extern volatile bit SEG2PHTS            @ ((unsigned)&BRGCON2*8)+7;
extern union {
    struct {
        volatile unsigned PRSEG0              : 1;
        volatile unsigned PRSEG1              : 1;
        volatile unsigned PRSEG2              : 1;
        volatile unsigned SEG1PH0             : 1;
        volatile unsigned SEG1PH1             : 1;
        volatile unsigned SEG1PH2             : 1;
        volatile unsigned SAM                 : 1;
        volatile unsigned SEG2PHTS            : 1;
    };
} BRGCON2bits @ 0xF71;

// Register: BRGCON3
extern volatile unsigned char           BRGCON3             @ 0xF72;
// bit and bitfield definitions
extern volatile bit SEG2PH0             @ ((unsigned)&BRGCON3*8)+0;
extern volatile bit SEG2PH1             @ ((unsigned)&BRGCON3*8)+1;
extern volatile bit SEG2PH2             @ ((unsigned)&BRGCON3*8)+2;
extern volatile bit WAKFIL              @ ((unsigned)&BRGCON3*8)+6;
extern union {
    struct {
        volatile unsigned SEG2PH0             : 1;
        volatile unsigned SEG2PH1             : 1;
        volatile unsigned SEG2PH2             : 1;
        volatile unsigned                     : 3;
        volatile unsigned WAKFIL              : 1;
    };
} BRGCON3bits @ 0xF72;

// Register: CIOCON
extern volatile unsigned char           CIOCON              @ 0xF73;
// bit and bitfield definitions
extern volatile bit CANCAP              @ ((unsigned)&CIOCON*8)+4;
extern volatile bit ENDRHI              @ ((unsigned)&CIOCON*8)+5;
extern union {
    struct {
        volatile unsigned                     : 4;
        volatile unsigned CANCAP              : 1;
        volatile unsigned ENDRHI              : 1;
    };
} CIOCONbits @ 0xF73;

// Register: COMSTAT
extern volatile unsigned char           COMSTAT             @ 0xF74;
// bit and bitfield definitions
extern volatile bit EWARN               @ ((unsigned)&COMSTAT*8)+0;
extern volatile bit RXWARN              @ ((unsigned)&COMSTAT*8)+1;
extern volatile bit TXWARN              @ ((unsigned)&COMSTAT*8)+2;
extern volatile bit RXBP                @ ((unsigned)&COMSTAT*8)+3;
extern volatile bit TXBP                @ ((unsigned)&COMSTAT*8)+4;
extern volatile bit TXBO                @ ((unsigned)&COMSTAT*8)+5;
extern volatile bit RXB1OVFL            @ ((unsigned)&COMSTAT*8)+6;
extern volatile bit RXB0OVFL            @ ((unsigned)&COMSTAT*8)+7;
extern volatile bit RX2OVFL             @ ((unsigned)&COMSTAT*8)+6;
extern volatile bit RX1OVFL             @ ((unsigned)&COMSTAT*8)+7;
extern union {
    struct {
        volatile unsigned EWARN               : 1;
        volatile unsigned RXWARN              : 1;
        volatile unsigned TXWARN              : 1;
        volatile unsigned RXBP                : 1;
        volatile unsigned TXBP                : 1;
        volatile unsigned TXBO                : 1;
        volatile unsigned RXB1OVFL            : 1;
        volatile unsigned RXB0OVFL            : 1;
    };
    struct {
        volatile unsigned                     : 6;
        volatile unsigned RX2OVFL             : 1;
        volatile unsigned RX1OVFL             : 1;
    };
} COMSTATbits @ 0xF74;

// Register: RXERRCNT
extern volatile unsigned char           RXERRCNT            @ 0xF75;
// bit and bitfield definitions
extern volatile bit REC0                @ ((unsigned)&RXERRCNT*8)+0;
extern volatile bit REC1                @ ((unsigned)&RXERRCNT*8)+1;
extern volatile bit REC2                @ ((unsigned)&RXERRCNT*8)+2;
extern volatile bit REC3                @ ((unsigned)&RXERRCNT*8)+3;
extern volatile bit REC4                @ ((unsigned)&RXERRCNT*8)+4;
extern volatile bit REC5                @ ((unsigned)&RXERRCNT*8)+5;
extern volatile bit REC6                @ ((unsigned)&RXERRCNT*8)+6;
extern volatile bit REC7                @ ((unsigned)&RXERRCNT*8)+7;
extern union {
    struct {
        volatile unsigned REC0                : 1;
        volatile unsigned REC1                : 1;
        volatile unsigned REC2                : 1;
        volatile unsigned REC3                : 1;
        volatile unsigned REC4                : 1;
        volatile unsigned REC5                : 1;
        volatile unsigned REC6                : 1;
        volatile unsigned REC7                : 1;
    };
} RXERRCNTbits @ 0xF75;

// Register: TXERRCNT
extern volatile unsigned char           TXERRCNT            @ 0xF76;
// bit and bitfield definitions
extern volatile bit TEC0                @ ((unsigned)&TXERRCNT*8)+0;
extern volatile bit TEC1                @ ((unsigned)&TXERRCNT*8)+1;
extern volatile bit TEC2                @ ((unsigned)&TXERRCNT*8)+2;
extern volatile bit TEC3                @ ((unsigned)&TXERRCNT*8)+3;
extern volatile bit TEC4                @ ((unsigned)&TXERRCNT*8)+4;
extern volatile bit TEC5                @ ((unsigned)&TXERRCNT*8)+5;
extern volatile bit TEC6                @ ((unsigned)&TXERRCNT*8)+6;
extern volatile bit TEC7                @ ((unsigned)&TXERRCNT*8)+7;
extern union {
    struct {
        volatile unsigned TEC0                : 1;
        volatile unsigned TEC1                : 1;
        volatile unsigned TEC2                : 1;
        volatile unsigned TEC3                : 1;
        volatile unsigned TEC4                : 1;
        volatile unsigned TEC5                : 1;
        volatile unsigned TEC6                : 1;
        volatile unsigned TEC7                : 1;
    };
} TXERRCNTbits @ 0xF76;

// Register: PORTA
extern volatile unsigned char           PORTA               @ 0xF80;
// bit and bitfield definitions
//extern volatile bit RA0                @ ((unsigned)&PORTA*8)+0;
//extern volatile bit RA1                @ ((unsigned)&PORTA*8)+1;
//extern volatile bit RA2                @ ((unsigned)&PORTA*8)+2;
//extern volatile bit RA3                @ ((unsigned)&PORTA*8)+3;
//extern volatile bit RA4                @ ((unsigned)&PORTA*8)+4;
//extern volatile bit RA5                @ ((unsigned)&PORTA*8)+5;
//extern volatile bit RA6                @ ((unsigned)&PORTA*8)+6;
extern volatile bit AN0                 @ ((unsigned)&PORTA*8)+0;
extern volatile bit AN1                 @ ((unsigned)&PORTA*8)+1;
extern volatile bit AN2                 @ ((unsigned)&PORTA*8)+2;
extern volatile bit AN3                 @ ((unsigned)&PORTA*8)+3;
extern volatile bit AN4                 @ ((unsigned)&PORTA*8)+5;
extern volatile bit OSC2                @ ((unsigned)&PORTA*8)+6;
extern volatile bit CVREF               @ ((unsigned)&PORTA*8)+0;
extern volatile bit VREFM               @ ((unsigned)&PORTA*8)+2;
extern volatile bit VREFP               @ ((unsigned)&PORTA*8)+3;
extern volatile bit T0CKI               @ ((unsigned)&PORTA*8)+4;
extern volatile bit nSS                 @ ((unsigned)&PORTA*8)+5;
extern volatile bit CLKO                @ ((unsigned)&PORTA*8)+6;
extern volatile bit SS                  @ ((unsigned)&PORTA*8)+5;
extern volatile bit LVDIN               @ ((unsigned)&PORTA*8)+5;
extern union {
    struct {
        volatile unsigned RA0                 : 1;
        volatile unsigned RA1                 : 1;
        volatile unsigned RA2                 : 1;
        volatile unsigned RA3                 : 1;
        volatile unsigned RA4                 : 1;
        volatile unsigned RA5                 : 1;
        volatile unsigned RA6                 : 1;
    };
    struct {
        volatile unsigned AN0                 : 1;
        volatile unsigned AN1                 : 1;
        volatile unsigned AN2                 : 1;
        volatile unsigned AN3                 : 1;
        volatile unsigned                     : 1;
        volatile unsigned AN4                 : 1;
        volatile unsigned OSC2                : 1;
    };
    struct {
        volatile unsigned CVREF               : 1;
        volatile unsigned : 1;
        volatile unsigned VREFM               : 1;
        volatile unsigned VREFP               : 1;
        volatile unsigned T0CKI               : 1;
        volatile unsigned nSS                 : 1;
        volatile unsigned CLKO                : 1;
    };
    struct {
        volatile unsigned : 5;
        volatile unsigned SS                  : 1;
    };
    struct {
        volatile unsigned : 5;
        volatile unsigned LVDIN               : 1;
    };
} PORTAbits @ 0xF80;

// Register: PORTB
extern volatile unsigned char           PORTB               @ 0xF81;
// bit and bitfield definitions
//extern volatile bit RB0                @ ((unsigned)&PORTB*8)+0;
//extern volatile bit RB1                @ ((unsigned)&PORTB*8)+1;
//extern volatile bit RB2                @ ((unsigned)&PORTB*8)+2;
//extern volatile bit RB3                @ ((unsigned)&PORTB*8)+3;
//extern volatile bit RB4                @ ((unsigned)&PORTB*8)+4;
//extern volatile bit RB5                @ ((unsigned)&PORTB*8)+5;
//extern volatile bit RB6                @ ((unsigned)&PORTB*8)+6;
//extern volatile bit RB7                @ ((unsigned)&PORTB*8)+7;
extern volatile bit INT0                @ ((unsigned)&PORTB*8)+0;
extern volatile bit INT1                @ ((unsigned)&PORTB*8)+1;
extern volatile bit CANTX               @ ((unsigned)&PORTB*8)+2;
extern volatile bit CANRX               @ ((unsigned)&PORTB*8)+3;
extern volatile bit PGM                 @ ((unsigned)&PORTB*8)+5;
extern volatile bit PGC                 @ ((unsigned)&PORTB*8)+6;
extern volatile bit PGD                 @ ((unsigned)&PORTB*8)+7;
extern union {
    struct {
        volatile unsigned RB0                 : 1;
        volatile unsigned RB1                 : 1;
        volatile unsigned RB2                 : 1;
        volatile unsigned RB3                 : 1;
        volatile unsigned RB4                 : 1;
        volatile unsigned RB5                 : 1;
        volatile unsigned RB6                 : 1;
        volatile unsigned RB7                 : 1;
    };
    struct {
        volatile unsigned INT0                : 1;
        volatile unsigned INT1                : 1;
        volatile unsigned CANTX               : 1;
        volatile unsigned CANRX               : 1;
        volatile unsigned                     : 1;
        volatile unsigned PGM                 : 1;
        volatile unsigned PGC                 : 1;
        volatile unsigned PGD                 : 1;
    };
} PORTBbits @ 0xF81;

// Register: PORTC
extern volatile unsigned char           PORTC               @ 0xF82;
// bit and bitfield definitions
//extern volatile bit RC0                @ ((unsigned)&PORTC*8)+0;
//extern volatile bit RC1                @ ((unsigned)&PORTC*8)+1;
//extern volatile bit RC2                @ ((unsigned)&PORTC*8)+2;
//extern volatile bit RC3                @ ((unsigned)&PORTC*8)+3;
//extern volatile bit RC4                @ ((unsigned)&PORTC*8)+4;
//extern volatile bit RC5                @ ((unsigned)&PORTC*8)+5;
//extern volatile bit RC6                @ ((unsigned)&PORTC*8)+6;
//extern volatile bit RC7                @ ((unsigned)&PORTC*8)+7;
extern volatile bit T1OSO               @ ((unsigned)&PORTC*8)+0;
extern volatile bit T1OSI               @ ((unsigned)&PORTC*8)+1;
extern volatile bit SCK                 @ ((unsigned)&PORTC*8)+3;
extern volatile bit SDI                 @ ((unsigned)&PORTC*8)+4;
extern volatile bit SDO                 @ ((unsigned)&PORTC*8)+5;
extern volatile bit TX                  @ ((unsigned)&PORTC*8)+6;
extern volatile bit RX                  @ ((unsigned)&PORTC*8)+7;
extern volatile bit T1CKI               @ ((unsigned)&PORTC*8)+0;
extern volatile bit CCP1                @ ((unsigned)&PORTC*8)+2;
extern volatile bit SCL                 @ ((unsigned)&PORTC*8)+3;
extern volatile bit SDA                 @ ((unsigned)&PORTC*8)+4;
extern volatile bit CK                  @ ((unsigned)&PORTC*8)+6;
extern volatile bit DT                  @ ((unsigned)&PORTC*8)+7;
extern union {
    struct {
        volatile unsigned RC0                 : 1;
        volatile unsigned RC1                 : 1;
        volatile unsigned RC2                 : 1;
        volatile unsigned RC3                 : 1;
        volatile unsigned RC4                 : 1;
        volatile unsigned RC5                 : 1;
        volatile unsigned RC6                 : 1;
        volatile unsigned RC7                 : 1;
    };
    struct {
        volatile unsigned T1OSO               : 1;
        volatile unsigned T1OSI               : 1;
        volatile unsigned                     : 1;
        volatile unsigned SCK                 : 1;
        volatile unsigned SDI                 : 1;
        volatile unsigned SDO                 : 1;
        volatile unsigned TX                  : 1;
        volatile unsigned RX                  : 1;
    };
    struct {
        volatile unsigned T1CKI               : 1;
        volatile unsigned : 1;
        volatile unsigned CCP1                : 1;
        volatile unsigned SCL                 : 1;
        volatile unsigned SDA                 : 1;
        volatile unsigned : 1;
        volatile unsigned CK                  : 1;
        volatile unsigned DT                  : 1;
    };
} PORTCbits @ 0xF82;

// Register: PORTD
extern volatile unsigned char           PORTD               @ 0xF83;
// bit and bitfield definitions
//extern volatile bit RD0                @ ((unsigned)&PORTD*8)+0;
//extern volatile bit RD1                @ ((unsigned)&PORTD*8)+1;
//extern volatile bit RD2                @ ((unsigned)&PORTD*8)+2;
//extern volatile bit RD3                @ ((unsigned)&PORTD*8)+3;
//extern volatile bit RD4                @ ((unsigned)&PORTD*8)+4;
//extern volatile bit RD5                @ ((unsigned)&PORTD*8)+5;
//extern volatile bit RD6                @ ((unsigned)&PORTD*8)+6;
//extern volatile bit RD7                @ ((unsigned)&PORTD*8)+7;
extern volatile bit C1INP               @ ((unsigned)&PORTD*8)+0;
extern volatile bit C1INM               @ ((unsigned)&PORTD*8)+1;
extern volatile bit C2INP               @ ((unsigned)&PORTD*8)+2;
extern volatile bit C2INM               @ ((unsigned)&PORTD*8)+3;
extern volatile bit P1A                 @ ((unsigned)&PORTD*8)+4;
extern volatile bit P1B                 @ ((unsigned)&PORTD*8)+5;
extern volatile bit P1C                 @ ((unsigned)&PORTD*8)+6;
extern volatile bit P1D                 @ ((unsigned)&PORTD*8)+7;
extern volatile bit ECCP1               @ ((unsigned)&PORTD*8)+4;
extern volatile bit PSP0                @ ((unsigned)&PORTD*8)+0;
extern volatile bit PSP1                @ ((unsigned)&PORTD*8)+1;
extern volatile bit PSP2                @ ((unsigned)&PORTD*8)+2;
extern volatile bit PSP3                @ ((unsigned)&PORTD*8)+3;
extern volatile bit PSP4                @ ((unsigned)&PORTD*8)+4;
extern volatile bit PSP5                @ ((unsigned)&PORTD*8)+5;
extern volatile bit PSP6                @ ((unsigned)&PORTD*8)+6;
extern volatile bit PSP7                @ ((unsigned)&PORTD*8)+7;
extern union {
    struct {
        volatile unsigned RD0                 : 1;
        volatile unsigned RD1                 : 1;
        volatile unsigned RD2                 : 1;
        volatile unsigned RD3                 : 1;
        volatile unsigned RD4                 : 1;
        volatile unsigned RD5                 : 1;
        volatile unsigned RD6                 : 1;
        volatile unsigned RD7                 : 1;
    };
    struct {
        volatile unsigned C1INP               : 1;
        volatile unsigned C1INM               : 1;
        volatile unsigned C2INP               : 1;
        volatile unsigned C2INM               : 1;
        volatile unsigned P1A                 : 1;
        volatile unsigned P1B                 : 1;
        volatile unsigned P1C                 : 1;
        volatile unsigned P1D                 : 1;
    };
    struct {
        volatile unsigned                     : 4;
        volatile unsigned ECCP1               : 1;
    };
    struct {
        volatile unsigned PSP0                : 1;
        volatile unsigned PSP1                : 1;
        volatile unsigned PSP2                : 1;
        volatile unsigned PSP3                : 1;
        volatile unsigned PSP4                : 1;
        volatile unsigned PSP5                : 1;
        volatile unsigned PSP6                : 1;
        volatile unsigned PSP7                : 1;
    };
} PORTDbits @ 0xF83;

// Register: PORTE
extern volatile unsigned char           PORTE               @ 0xF84;
// bit and bitfield definitions
//extern volatile bit RE0                @ ((unsigned)&PORTE*8)+0;
//extern volatile bit RE1                @ ((unsigned)&PORTE*8)+1;
//extern volatile bit RE2                @ ((unsigned)&PORTE*8)+2;
extern volatile bit AN5                 @ ((unsigned)&PORTE*8)+0;
extern volatile bit AN6                 @ ((unsigned)&PORTE*8)+1;
extern volatile bit AN7                 @ ((unsigned)&PORTE*8)+2;
extern volatile bit nRD                 @ ((unsigned)&PORTE*8)+0;
extern volatile bit nWR                 @ ((unsigned)&PORTE*8)+1;
extern volatile bit nCS                 @ ((unsigned)&PORTE*8)+2;
//extern volatile bit RD                 @ ((unsigned)&PORTE*8)+0;
//extern volatile bit WR                 @ ((unsigned)&PORTE*8)+1;
extern volatile bit CS                  @ ((unsigned)&PORTE*8)+2;
extern union {
    struct {
        volatile unsigned RE0                 : 1;
        volatile unsigned RE1                 : 1;
        volatile unsigned RE2                 : 1;
    };
    struct {
        volatile unsigned AN5                 : 1;
        volatile unsigned AN6                 : 1;
        volatile unsigned AN7                 : 1;
    };
    struct {
        volatile unsigned nRD                 : 1;
        volatile unsigned nWR                 : 1;
        volatile unsigned nCS                 : 1;
    };
    struct {
        volatile unsigned RD                  : 1;
        volatile unsigned WR                  : 1;
        volatile unsigned CS                  : 1;
    };
} PORTEbits @ 0xF84;

// Register: LATA
extern volatile unsigned char           LATA                @ 0xF89;
// bit and bitfield definitions
extern volatile bit LATA0               @ ((unsigned)&LATA*8)+0;
extern volatile bit LATA1               @ ((unsigned)&LATA*8)+1;
extern volatile bit LATA2               @ ((unsigned)&LATA*8)+2;
extern volatile bit LATA3               @ ((unsigned)&LATA*8)+3;
extern volatile bit LATA4               @ ((unsigned)&LATA*8)+4;
extern volatile bit LATA5               @ ((unsigned)&LATA*8)+5;
extern volatile bit LATA6               @ ((unsigned)&LATA*8)+6;
extern union {
    struct {
        volatile unsigned LATA0               : 1;
        volatile unsigned LATA1               : 1;
        volatile unsigned LATA2               : 1;
        volatile unsigned LATA3               : 1;
        volatile unsigned LATA4               : 1;
        volatile unsigned LATA5               : 1;
        volatile unsigned LATA6               : 1;
    };
} LATAbits @ 0xF89;

// Register: LATB
extern volatile unsigned char           LATB                @ 0xF8A;
// bit and bitfield definitions
extern volatile bit LATB0               @ ((unsigned)&LATB*8)+0;
extern volatile bit LATB1               @ ((unsigned)&LATB*8)+1;
extern volatile bit LATB2               @ ((unsigned)&LATB*8)+2;
extern volatile bit LATB3               @ ((unsigned)&LATB*8)+3;
extern volatile bit LATB4               @ ((unsigned)&LATB*8)+4;
extern volatile bit LATB5               @ ((unsigned)&LATB*8)+5;
extern volatile bit LATB6               @ ((unsigned)&LATB*8)+6;
extern volatile bit LATB7               @ ((unsigned)&LATB*8)+7;
extern union {
    struct {
        volatile unsigned LATB0               : 1;
        volatile unsigned LATB1               : 1;
        volatile unsigned LATB2               : 1;
        volatile unsigned LATB3               : 1;
        volatile unsigned LATB4               : 1;
        volatile unsigned LATB5               : 1;
        volatile unsigned LATB6               : 1;
        volatile unsigned LATB7               : 1;
    };
} LATBbits @ 0xF8A;

// Register: LATC
extern volatile unsigned char           LATC                @ 0xF8B;
// bit and bitfield definitions
extern volatile bit LATC0               @ ((unsigned)&LATC*8)+0;
extern volatile bit LATC1               @ ((unsigned)&LATC*8)+1;
extern volatile bit LATC2               @ ((unsigned)&LATC*8)+2;
extern volatile bit LATC3               @ ((unsigned)&LATC*8)+3;
extern volatile bit LATC4               @ ((unsigned)&LATC*8)+4;
extern volatile bit LATC5               @ ((unsigned)&LATC*8)+5;
extern volatile bit LATC6               @ ((unsigned)&LATC*8)+6;
extern volatile bit LATC7               @ ((unsigned)&LATC*8)+7;
extern union {
    struct {
        volatile unsigned LATC0               : 1;
        volatile unsigned LATC1               : 1;
        volatile unsigned LATC2               : 1;
        volatile unsigned LATC3               : 1;
        volatile unsigned LATC4               : 1;
        volatile unsigned LATC5               : 1;
        volatile unsigned LATC6               : 1;
        volatile unsigned LATC7               : 1;
    };
} LATCbits @ 0xF8B;

// Register: LATD
extern volatile unsigned char           LATD                @ 0xF8C;
// bit and bitfield definitions
extern volatile bit LATD0               @ ((unsigned)&LATD*8)+0;
extern volatile bit LATD1               @ ((unsigned)&LATD*8)+1;
extern volatile bit LATD2               @ ((unsigned)&LATD*8)+2;
extern volatile bit LATD3               @ ((unsigned)&LATD*8)+3;
extern volatile bit LATD4               @ ((unsigned)&LATD*8)+4;
extern volatile bit LATD5               @ ((unsigned)&LATD*8)+5;
extern volatile bit LATD6               @ ((unsigned)&LATD*8)+6;
extern volatile bit LATD7               @ ((unsigned)&LATD*8)+7;
extern union {
    struct {
        volatile unsigned LATD0               : 1;
        volatile unsigned LATD1               : 1;
        volatile unsigned LATD2               : 1;
        volatile unsigned LATD3               : 1;
        volatile unsigned LATD4               : 1;
        volatile unsigned LATD5               : 1;
        volatile unsigned LATD6               : 1;
        volatile unsigned LATD7               : 1;
    };
} LATDbits @ 0xF8C;

// Register: LATE
extern volatile unsigned char           LATE                @ 0xF8D;
// bit and bitfield definitions
extern volatile bit LATE0               @ ((unsigned)&LATE*8)+0;
extern volatile bit LATE1               @ ((unsigned)&LATE*8)+1;
extern volatile bit LATE2               @ ((unsigned)&LATE*8)+2;
extern union {
    struct {
        volatile unsigned LATE0               : 1;
        volatile unsigned LATE1               : 1;
        volatile unsigned LATE2               : 1;
    };
} LATEbits @ 0xF8D;

// Register: TRISA
extern volatile unsigned char           TRISA               @ 0xF92;
extern volatile unsigned char           DDRA                @ 0xF92;
// bit and bitfield definitions
extern volatile bit TRISA0              @ ((unsigned)&TRISA*8)+0;
extern volatile bit TRISA1              @ ((unsigned)&TRISA*8)+1;
extern volatile bit TRISA2              @ ((unsigned)&TRISA*8)+2;
extern volatile bit TRISA3              @ ((unsigned)&TRISA*8)+3;
extern volatile bit TRISA4              @ ((unsigned)&TRISA*8)+4;
extern volatile bit TRISA5              @ ((unsigned)&TRISA*8)+5;
extern volatile bit TRISA6              @ ((unsigned)&TRISA*8)+6;
//extern volatile bit RA0                @ ((unsigned)&TRISA*8)+0;
//extern volatile bit RA1                @ ((unsigned)&TRISA*8)+1;
//extern volatile bit RA2                @ ((unsigned)&TRISA*8)+2;
//extern volatile bit RA3                @ ((unsigned)&TRISA*8)+3;
//extern volatile bit RA4                @ ((unsigned)&TRISA*8)+4;
//extern volatile bit RA5                @ ((unsigned)&TRISA*8)+5;
//extern volatile bit RA6                @ ((unsigned)&TRISA*8)+6;
extern union {
    struct {
        volatile unsigned TRISA0              : 1;
        volatile unsigned TRISA1              : 1;
        volatile unsigned TRISA2              : 1;
        volatile unsigned TRISA3              : 1;
        volatile unsigned TRISA4              : 1;
        volatile unsigned TRISA5              : 1;
        volatile unsigned TRISA6              : 1;
    };
    struct {
        volatile unsigned RA0                 : 1;
        volatile unsigned RA1                 : 1;
        volatile unsigned RA2                 : 1;
        volatile unsigned RA3                 : 1;
        volatile unsigned RA4                 : 1;
        volatile unsigned RA5                 : 1;
        volatile unsigned RA6                 : 1;
    };
} TRISAbits @ 0xF92;

// Register: TRISB
extern volatile unsigned char           TRISB               @ 0xF93;
extern volatile unsigned char           DDRB                @ 0xF93;
// bit and bitfield definitions
extern volatile bit TRISB0              @ ((unsigned)&TRISB*8)+0;
extern volatile bit TRISB1              @ ((unsigned)&TRISB*8)+1;
extern volatile bit TRISB2              @ ((unsigned)&TRISB*8)+2;
extern volatile bit TRISB3              @ ((unsigned)&TRISB*8)+3;
extern volatile bit TRISB4              @ ((unsigned)&TRISB*8)+4;
extern volatile bit TRISB5              @ ((unsigned)&TRISB*8)+5;
extern volatile bit TRISB6              @ ((unsigned)&TRISB*8)+6;
extern volatile bit TRISB7              @ ((unsigned)&TRISB*8)+7;
//extern volatile bit RB0                @ ((unsigned)&TRISB*8)+0;
//extern volatile bit RB1                @ ((unsigned)&TRISB*8)+1;
//extern volatile bit RB2                @ ((unsigned)&TRISB*8)+2;
//extern volatile bit RB3                @ ((unsigned)&TRISB*8)+3;
//extern volatile bit RB4                @ ((unsigned)&TRISB*8)+4;
//extern volatile bit RB5                @ ((unsigned)&TRISB*8)+5;
//extern volatile bit RB6                @ ((unsigned)&TRISB*8)+6;
//extern volatile bit RB7                @ ((unsigned)&TRISB*8)+7;
extern union {
    struct {
        volatile unsigned TRISB0              : 1;
        volatile unsigned TRISB1              : 1;
        volatile unsigned TRISB2              : 1;
        volatile unsigned TRISB3              : 1;
        volatile unsigned TRISB4              : 1;
        volatile unsigned TRISB5              : 1;
        volatile unsigned TRISB6              : 1;
        volatile unsigned TRISB7              : 1;
    };
    struct {
        volatile unsigned RB0                 : 1;
        volatile unsigned RB1                 : 1;
        volatile unsigned RB2                 : 1;
        volatile unsigned RB3                 : 1;
        volatile unsigned RB4                 : 1;
        volatile unsigned RB5                 : 1;
        volatile unsigned RB6                 : 1;
        volatile unsigned RB7                 : 1;
    };
} TRISBbits @ 0xF93;

// Register: TRISC
extern volatile unsigned char           TRISC               @ 0xF94;
extern volatile unsigned char           DDRC                @ 0xF94;
// bit and bitfield definitions
extern volatile bit TRISC0              @ ((unsigned)&TRISC*8)+0;
extern volatile bit TRISC1              @ ((unsigned)&TRISC*8)+1;
extern volatile bit TRISC2              @ ((unsigned)&TRISC*8)+2;
extern volatile bit TRISC3              @ ((unsigned)&TRISC*8)+3;
extern volatile bit TRISC4              @ ((unsigned)&TRISC*8)+4;
extern volatile bit TRISC5              @ ((unsigned)&TRISC*8)+5;
extern volatile bit TRISC6              @ ((unsigned)&TRISC*8)+6;
extern volatile bit TRISC7              @ ((unsigned)&TRISC*8)+7;
//extern volatile bit RC0                @ ((unsigned)&TRISC*8)+0;
//extern volatile bit RC1                @ ((unsigned)&TRISC*8)+1;
//extern volatile bit RC2                @ ((unsigned)&TRISC*8)+2;
//extern volatile bit RC3                @ ((unsigned)&TRISC*8)+3;
//extern volatile bit RC4                @ ((unsigned)&TRISC*8)+4;
//extern volatile bit RC5                @ ((unsigned)&TRISC*8)+5;
//extern volatile bit RC6                @ ((unsigned)&TRISC*8)+6;
//extern volatile bit RC7                @ ((unsigned)&TRISC*8)+7;
extern union {
    struct {
        volatile unsigned TRISC0              : 1;
        volatile unsigned TRISC1              : 1;
        volatile unsigned TRISC2              : 1;
        volatile unsigned TRISC3              : 1;
        volatile unsigned TRISC4              : 1;
        volatile unsigned TRISC5              : 1;
        volatile unsigned TRISC6              : 1;
        volatile unsigned TRISC7              : 1;
    };
    struct {
        volatile unsigned RC0                 : 1;
        volatile unsigned RC1                 : 1;
        volatile unsigned RC2                 : 1;
        volatile unsigned RC3                 : 1;
        volatile unsigned RC4                 : 1;
        volatile unsigned RC5                 : 1;
        volatile unsigned RC6                 : 1;
        volatile unsigned RC7                 : 1;
    };
} TRISCbits @ 0xF94;

// Register: TRISD
extern volatile unsigned char           TRISD               @ 0xF95;
extern volatile unsigned char           DDRD                @ 0xF95;
// bit and bitfield definitions
extern volatile bit TRISD0              @ ((unsigned)&TRISD*8)+0;
extern volatile bit TRISD1              @ ((unsigned)&TRISD*8)+1;
extern volatile bit TRISD2              @ ((unsigned)&TRISD*8)+2;
extern volatile bit TRISD3              @ ((unsigned)&TRISD*8)+3;
extern volatile bit TRISD4              @ ((unsigned)&TRISD*8)+4;
extern volatile bit TRISD5              @ ((unsigned)&TRISD*8)+5;
extern volatile bit TRISD6              @ ((unsigned)&TRISD*8)+6;
extern volatile bit TRISD7              @ ((unsigned)&TRISD*8)+7;
//extern volatile bit RD0                @ ((unsigned)&TRISD*8)+0;
//extern volatile bit RD1                @ ((unsigned)&TRISD*8)+1;
//extern volatile bit RD2                @ ((unsigned)&TRISD*8)+2;
//extern volatile bit RD3                @ ((unsigned)&TRISD*8)+3;
//extern volatile bit RD4                @ ((unsigned)&TRISD*8)+4;
//extern volatile bit RD5                @ ((unsigned)&TRISD*8)+5;
//extern volatile bit RD6                @ ((unsigned)&TRISD*8)+6;
//extern volatile bit RD7                @ ((unsigned)&TRISD*8)+7;
extern union {
    struct {
        volatile unsigned TRISD0              : 1;
        volatile unsigned TRISD1              : 1;
        volatile unsigned TRISD2              : 1;
        volatile unsigned TRISD3              : 1;
        volatile unsigned TRISD4              : 1;
        volatile unsigned TRISD5              : 1;
        volatile unsigned TRISD6              : 1;
        volatile unsigned TRISD7              : 1;
    };
    struct {
        volatile unsigned RD0                 : 1;
        volatile unsigned RD1                 : 1;
        volatile unsigned RD2                 : 1;
        volatile unsigned RD3                 : 1;
        volatile unsigned RD4                 : 1;
        volatile unsigned RD5                 : 1;
        volatile unsigned RD6                 : 1;
        volatile unsigned RD7                 : 1;
    };
} TRISDbits @ 0xF95;

// Register: TRISE
extern volatile unsigned char           TRISE               @ 0xF96;
extern volatile unsigned char           DDRE                @ 0xF96;
// bit and bitfield definitions
extern volatile bit TRISE0              @ ((unsigned)&TRISE*8)+0;
extern volatile bit TRISE1              @ ((unsigned)&TRISE*8)+1;
extern volatile bit TRISE2              @ ((unsigned)&TRISE*8)+2;
extern volatile bit PSPMODE             @ ((unsigned)&TRISE*8)+4;
extern volatile bit IBOV                @ ((unsigned)&TRISE*8)+5;
extern volatile bit OBF                 @ ((unsigned)&TRISE*8)+6;
extern volatile bit IBF                 @ ((unsigned)&TRISE*8)+7;
//extern volatile bit RE0                @ ((unsigned)&TRISE*8)+0;
//extern volatile bit RE1                @ ((unsigned)&TRISE*8)+1;
//extern volatile bit RE2                @ ((unsigned)&TRISE*8)+2;
extern volatile bit DDRE0               @ ((unsigned)&TRISE*8)+0;
extern volatile bit DDRE1               @ ((unsigned)&TRISE*8)+1;
extern volatile bit DDRE2               @ ((unsigned)&TRISE*8)+2;
extern union {
    struct {
        volatile unsigned TRISE0              : 1;
        volatile unsigned TRISE1              : 1;
        volatile unsigned TRISE2              : 1;
        volatile unsigned                     : 1;
        volatile unsigned PSPMODE             : 1;
        volatile unsigned IBOV                : 1;
        volatile unsigned OBF                 : 1;
        volatile unsigned IBF                 : 1;
    };
    struct {
        volatile unsigned RE0                 : 1;
        volatile unsigned RE1                 : 1;
        volatile unsigned RE2                 : 1;
    };
    struct {
        volatile unsigned DDRE0               : 1;
        volatile unsigned DDRE1               : 1;
        volatile unsigned DDRE2               : 1;
    };
} TRISEbits @ 0xF96;

// Register: PIE1
extern volatile unsigned char           PIE1                @ 0xF9D;
// bit and bitfield definitions
extern volatile bit TMR1IE              @ ((unsigned)&PIE1*8)+0;
extern volatile bit TMR2IE              @ ((unsigned)&PIE1*8)+1;
extern volatile bit CCP1IE              @ ((unsigned)&PIE1*8)+2;
extern volatile bit SSPIE               @ ((unsigned)&PIE1*8)+3;
extern volatile bit TXIE                @ ((unsigned)&PIE1*8)+4;
extern volatile bit RCIE                @ ((unsigned)&PIE1*8)+5;
extern volatile bit ADIE                @ ((unsigned)&PIE1*8)+6;
extern volatile bit PSPIE               @ ((unsigned)&PIE1*8)+7;
extern union {
    struct {
        volatile unsigned TMR1IE              : 1;
        volatile unsigned TMR2IE              : 1;
        volatile unsigned CCP1IE              : 1;
        volatile unsigned SSPIE               : 1;
        volatile unsigned TXIE                : 1;
        volatile unsigned RCIE                : 1;
        volatile unsigned ADIE                : 1;
        volatile unsigned PSPIE               : 1;
    };
} PIE1bits @ 0xF9D;

// Register: PIR1
extern volatile unsigned char           PIR1                @ 0xF9E;
// bit and bitfield definitions
extern volatile bit TMR1IF              @ ((unsigned)&PIR1*8)+0;
extern volatile bit TMR2IF              @ ((unsigned)&PIR1*8)+1;
extern volatile bit CCP1IF              @ ((unsigned)&PIR1*8)+2;
extern volatile bit SSPIF               @ ((unsigned)&PIR1*8)+3;
extern volatile bit TXIF                @ ((unsigned)&PIR1*8)+4;
extern volatile bit RCIF                @ ((unsigned)&PIR1*8)+5;
extern volatile bit ADIF                @ ((unsigned)&PIR1*8)+6;
extern volatile bit PSPIF               @ ((unsigned)&PIR1*8)+7;
extern union {
    struct {
        volatile unsigned TMR1IF              : 1;
        volatile unsigned TMR2IF              : 1;
        volatile unsigned CCP1IF              : 1;
        volatile unsigned SSPIF               : 1;
        volatile unsigned TXIF                : 1;
        volatile unsigned RCIF                : 1;
        volatile unsigned ADIF                : 1;
        volatile unsigned PSPIF               : 1;
    };
    struct {
        volatile unsigned : 1;
        volatile unsigned : 1;
        volatile unsigned : 1;
        volatile unsigned : 1;
        volatile unsigned                     : 2;
        volatile unsigned : 1;
        volatile unsigned : 1;
    };
} PIR1bits @ 0xF9E;

// Register: IPR1
extern volatile unsigned char           IPR1                @ 0xF9F;
// bit and bitfield definitions
extern volatile bit TMR1IP              @ ((unsigned)&IPR1*8)+0;
extern volatile bit TMR2IP              @ ((unsigned)&IPR1*8)+1;
extern volatile bit CCP1IP              @ ((unsigned)&IPR1*8)+2;
extern volatile bit SSPIP               @ ((unsigned)&IPR1*8)+3;
extern volatile bit TXIP                @ ((unsigned)&IPR1*8)+4;
extern volatile bit RCIP                @ ((unsigned)&IPR1*8)+5;
extern volatile bit ADIP                @ ((unsigned)&IPR1*8)+6;
extern volatile bit PSPIP               @ ((unsigned)&IPR1*8)+7;
extern union {
    struct {
        volatile unsigned TMR1IP              : 1;
        volatile unsigned TMR2IP              : 1;
        volatile unsigned CCP1IP              : 1;
        volatile unsigned SSPIP               : 1;
        volatile unsigned TXIP                : 1;
        volatile unsigned RCIP                : 1;
        volatile unsigned ADIP                : 1;
        volatile unsigned PSPIP               : 1;
    };
} IPR1bits @ 0xF9F;

// Register: PIE2
extern volatile unsigned char           PIE2                @ 0xFA0;
// bit and bitfield definitions
extern volatile bit ECCP1IE             @ ((unsigned)&PIE2*8)+0;
extern volatile bit TMR3IE              @ ((unsigned)&PIE2*8)+1;
extern volatile bit LVDIE               @ ((unsigned)&PIE2*8)+2;
extern volatile bit BCLIE               @ ((unsigned)&PIE2*8)+3;
extern volatile bit EEIE                @ ((unsigned)&PIE2*8)+4;
extern volatile bit CMIE                @ ((unsigned)&PIE2*8)+6;
extern union {
    struct {
        volatile unsigned ECCP1IE             : 1;
        volatile unsigned TMR3IE              : 1;
        volatile unsigned LVDIE               : 1;
        volatile unsigned BCLIE               : 1;
        volatile unsigned EEIE                : 1;
        volatile unsigned                     : 1;
        volatile unsigned CMIE                : 1;
    };
} PIE2bits @ 0xFA0;

// Register: PIR2
extern volatile unsigned char           PIR2                @ 0xFA1;
// bit and bitfield definitions
extern volatile bit ECCP1IF             @ ((unsigned)&PIR2*8)+0;
extern volatile bit TMR3IF              @ ((unsigned)&PIR2*8)+1;
extern volatile bit LVDIF               @ ((unsigned)&PIR2*8)+2;
extern volatile bit BCLIF               @ ((unsigned)&PIR2*8)+3;
extern volatile bit EEIF                @ ((unsigned)&PIR2*8)+4;
extern volatile bit CMIF                @ ((unsigned)&PIR2*8)+6;
extern union {
    struct {
        volatile unsigned ECCP1IF             : 1;
        volatile unsigned TMR3IF              : 1;
        volatile unsigned LVDIF               : 1;
        volatile unsigned BCLIF               : 1;
        volatile unsigned EEIF                : 1;
        volatile unsigned                     : 1;
        volatile unsigned CMIF                : 1;
    };
} PIR2bits @ 0xFA1;

// Register: IPR2
extern volatile unsigned char           IPR2                @ 0xFA2;
// bit and bitfield definitions
extern volatile bit ECCP1IP             @ ((unsigned)&IPR2*8)+0;
extern volatile bit TMR3IP              @ ((unsigned)&IPR2*8)+1;
extern volatile bit LVDIP               @ ((unsigned)&IPR2*8)+2;
extern volatile bit BCLIP               @ ((unsigned)&IPR2*8)+3;
extern volatile bit EEIP                @ ((unsigned)&IPR2*8)+4;
extern volatile bit CMIP                @ ((unsigned)&IPR2*8)+6;
extern union {
    struct {
        volatile unsigned ECCP1IP             : 1;
        volatile unsigned TMR3IP              : 1;
        volatile unsigned LVDIP               : 1;
        volatile unsigned BCLIP               : 1;
        volatile unsigned EEIP                : 1;
        volatile unsigned                     : 1;
        volatile unsigned CMIP                : 1;
    };
} IPR2bits @ 0xFA2;

// Register: PIE3
extern volatile unsigned char           PIE3                @ 0xFA3;
// bit and bitfield definitions
extern volatile bit RXB0IE              @ ((unsigned)&PIE3*8)+0;
extern volatile bit RXB1IE              @ ((unsigned)&PIE3*8)+1;
extern volatile bit TXB0IE              @ ((unsigned)&PIE3*8)+2;
extern volatile bit TXB1IE              @ ((unsigned)&PIE3*8)+3;
extern volatile bit TXB2IE              @ ((unsigned)&PIE3*8)+4;
extern volatile bit ERRIE               @ ((unsigned)&PIE3*8)+5;
extern volatile bit WAKIE               @ ((unsigned)&PIE3*8)+6;
extern volatile bit IRXIE               @ ((unsigned)&PIE3*8)+7;
extern volatile bit RX0IE               @ ((unsigned)&PIE3*8)+0;
extern volatile bit RX1IE               @ ((unsigned)&PIE3*8)+1;
extern volatile bit TX0IE               @ ((unsigned)&PIE3*8)+2;
extern volatile bit TX1IE               @ ((unsigned)&PIE3*8)+3;
extern volatile bit TX2IE               @ ((unsigned)&PIE3*8)+4;
extern volatile bit IVRE                @ ((unsigned)&PIE3*8)+7;
extern union {
    struct {
        volatile unsigned RXB0IE              : 1;
        volatile unsigned RXB1IE              : 1;
        volatile unsigned TXB0IE              : 1;
        volatile unsigned TXB1IE              : 1;
        volatile unsigned TXB2IE              : 1;
        volatile unsigned ERRIE               : 1;
        volatile unsigned WAKIE               : 1;
        volatile unsigned IRXIE               : 1;
    };
    struct {
        volatile unsigned RX0IE               : 1;
        volatile unsigned RX1IE               : 1;
        volatile unsigned TX0IE               : 1;
        volatile unsigned TX1IE               : 1;
        volatile unsigned TX2IE               : 1;
        volatile unsigned                     : 2;
        volatile unsigned IVRE                : 1;
    };
} PIE3bits @ 0xFA3;

// Register: PIR3
extern volatile unsigned char           PIR3                @ 0xFA4;
// bit and bitfield definitions
extern volatile bit RXB0IF              @ ((unsigned)&PIR3*8)+0;
extern volatile bit RXB1IF              @ ((unsigned)&PIR3*8)+1;
extern volatile bit TXB0IF              @ ((unsigned)&PIR3*8)+2;
extern volatile bit TXB1IF              @ ((unsigned)&PIR3*8)+3;
extern volatile bit TXB2IF              @ ((unsigned)&PIR3*8)+4;
extern volatile bit ERRIF               @ ((unsigned)&PIR3*8)+5;
extern volatile bit WAKIF               @ ((unsigned)&PIR3*8)+6;
extern volatile bit IRXIF               @ ((unsigned)&PIR3*8)+7;
extern volatile bit RX0IF               @ ((unsigned)&PIR3*8)+0;
extern volatile bit RX1IF               @ ((unsigned)&PIR3*8)+1;
extern volatile bit TX0IF               @ ((unsigned)&PIR3*8)+2;
extern volatile bit TX1IF               @ ((unsigned)&PIR3*8)+3;
extern volatile bit TX2IF               @ ((unsigned)&PIR3*8)+4;
extern volatile bit IVRF                @ ((unsigned)&PIR3*8)+7;
extern union {
    struct {
        volatile unsigned RXB0IF              : 1;
        volatile unsigned RXB1IF              : 1;
        volatile unsigned TXB0IF              : 1;
        volatile unsigned TXB1IF              : 1;
        volatile unsigned TXB2IF              : 1;
        volatile unsigned ERRIF               : 1;
        volatile unsigned WAKIF               : 1;
        volatile unsigned IRXIF               : 1;
    };
    struct {
        volatile unsigned RX0IF               : 1;
        volatile unsigned RX1IF               : 1;
        volatile unsigned TX0IF               : 1;
        volatile unsigned TX1IF               : 1;
        volatile unsigned TX2IF               : 1;
        volatile unsigned                     : 2;
        volatile unsigned IVRF                : 1;
    };
} PIR3bits @ 0xFA4;

// Register: IPR3
extern volatile unsigned char           IPR3                @ 0xFA5;
// bit and bitfield definitions
extern volatile bit RXB0IP              @ ((unsigned)&IPR3*8)+0;
extern volatile bit RXB1IP              @ ((unsigned)&IPR3*8)+1;
extern volatile bit TXB0IP              @ ((unsigned)&IPR3*8)+2;
extern volatile bit TXB1IP              @ ((unsigned)&IPR3*8)+3;
extern volatile bit TXB2IP              @ ((unsigned)&IPR3*8)+4;
extern volatile bit ERRIP               @ ((unsigned)&IPR3*8)+5;
extern volatile bit WAKIP               @ ((unsigned)&IPR3*8)+6;
extern volatile bit IRXIP               @ ((unsigned)&IPR3*8)+7;
extern volatile bit IVRP                @ ((unsigned)&IPR3*8)+7;
extern union {
    struct {
        volatile unsigned RXB0IP              : 1;
        volatile unsigned RXB1IP              : 1;
        volatile unsigned TXB0IP              : 1;
        volatile unsigned TXB1IP              : 1;
        volatile unsigned TXB2IP              : 1;
        volatile unsigned ERRIP               : 1;
        volatile unsigned WAKIP               : 1;
        volatile unsigned IRXIP               : 1;
    };
    struct {
        volatile unsigned                     : 7;
        volatile unsigned IVRP                : 1;
    };
} IPR3bits @ 0xFA5;

// Register: EECON1
extern volatile unsigned char           EECON1              @ 0xFA6;
// bit and bitfield definitions
//extern volatile bit RD                 @ ((unsigned)&EECON1*8)+0;
//extern volatile bit WR                 @ ((unsigned)&EECON1*8)+1;
extern volatile bit WREN                @ ((unsigned)&EECON1*8)+2;
extern volatile bit WRERR               @ ((unsigned)&EECON1*8)+3;
extern volatile bit FREE                @ ((unsigned)&EECON1*8)+4;
extern volatile bit CFGS                @ ((unsigned)&EECON1*8)+6;
extern volatile bit EEPGD               @ ((unsigned)&EECON1*8)+7;
extern volatile bit EEFS                @ ((unsigned)&EECON1*8)+6;
extern union {
    struct {
        volatile unsigned RD                  : 1;
        volatile unsigned WR                  : 1;
        volatile unsigned WREN                : 1;
        volatile unsigned WRERR               : 1;
        volatile unsigned FREE                : 1;
        volatile unsigned                     : 1;
        volatile unsigned CFGS                : 1;
        volatile unsigned EEPGD               : 1;
    };
    struct {
        volatile unsigned : 6;
        volatile unsigned EEFS                : 1;
    };
} EECON1bits @ 0xFA6;

// Register: EECON2
extern volatile unsigned char           EECON2              @ 0xFA7;
// bit and bitfield definitions

// Register: EEDATA
extern volatile unsigned char           EEDATA              @ 0xFA8;
// bit and bitfield definitions

// Register: EEADR
extern volatile unsigned char           EEADR               @ 0xFA9;
// bit and bitfield definitions

// Register: RCSTA
extern volatile unsigned char           RCSTA               @ 0xFAB;
// bit and bitfield definitions
extern volatile bit RX9D                @ ((unsigned)&RCSTA*8)+0;
extern volatile bit OERR                @ ((unsigned)&RCSTA*8)+1;
extern volatile bit FERR                @ ((unsigned)&RCSTA*8)+2;
extern volatile bit ADDEN               @ ((unsigned)&RCSTA*8)+3;
extern volatile bit CREN                @ ((unsigned)&RCSTA*8)+4;
extern volatile bit SREN                @ ((unsigned)&RCSTA*8)+5;
extern volatile bit RX9                 @ ((unsigned)&RCSTA*8)+6;
extern volatile bit SPEN                @ ((unsigned)&RCSTA*8)+7;
extern volatile bit RCD8                @ ((unsigned)&RCSTA*8)+0;
extern volatile bit RC9                 @ ((unsigned)&RCSTA*8)+6;
extern volatile bit RC8_9               @ ((unsigned)&RCSTA*8)+6;
extern volatile bit nRC8                @ ((unsigned)&RCSTA*8)+6;
extern union {
    struct {
        volatile unsigned RX9D                : 1;
        volatile unsigned OERR                : 1;
        volatile unsigned FERR                : 1;
        volatile unsigned ADDEN               : 1;
        volatile unsigned CREN                : 1;
        volatile unsigned SREN                : 1;
        volatile unsigned RX9                 : 1;
        volatile unsigned SPEN                : 1;
    };
    struct {
        volatile unsigned RCD8                : 1;
        volatile unsigned                     : 5;
        volatile unsigned RC9                 : 1;
    };
    struct {
        volatile unsigned : 6;
        volatile unsigned RC8_9               : 1;
    };
    struct {
        volatile unsigned : 6;
        volatile unsigned nRC8                : 1;
    };
} RCSTAbits @ 0xFAB;

// Register: TXSTA
extern volatile unsigned char           TXSTA               @ 0xFAC;
// bit and bitfield definitions
extern volatile bit TX9D                @ ((unsigned)&TXSTA*8)+0;
extern volatile bit TRMT                @ ((unsigned)&TXSTA*8)+1;
extern volatile bit BRGH                @ ((unsigned)&TXSTA*8)+2;
extern volatile bit SYNC                @ ((unsigned)&TXSTA*8)+4;
extern volatile bit TXEN                @ ((unsigned)&TXSTA*8)+5;
extern volatile bit TX9                 @ ((unsigned)&TXSTA*8)+6;
extern volatile bit CSRC                @ ((unsigned)&TXSTA*8)+7;
extern volatile bit TXD8                @ ((unsigned)&TXSTA*8)+0;
extern volatile bit TX8_9               @ ((unsigned)&TXSTA*8)+6;
extern volatile bit nTX8                @ ((unsigned)&TXSTA*8)+6;
extern union {
    struct {
        volatile unsigned TX9D                : 1;
        volatile unsigned TRMT                : 1;
        volatile unsigned BRGH                : 1;
        volatile unsigned                     : 1;
        volatile unsigned SYNC                : 1;
        volatile unsigned TXEN                : 1;
        volatile unsigned TX9                 : 1;
        volatile unsigned CSRC                : 1;
    };
    struct {
        volatile unsigned TXD8                : 1;
        volatile unsigned : 5;
        volatile unsigned TX8_9               : 1;
    };
    struct {
        volatile unsigned : 6;
        volatile unsigned nTX8                : 1;
    };
} TXSTAbits @ 0xFAC;

// Register: TXREG
extern volatile unsigned char           TXREG               @ 0xFAD;
// bit and bitfield definitions

// Register: RCREG
extern volatile unsigned char           RCREG               @ 0xFAE;
// bit and bitfield definitions

// Register: SPBRG
extern volatile unsigned char           SPBRG               @ 0xFAF;
// bit and bitfield definitions

// Register: T3CON
extern volatile unsigned char           T3CON               @ 0xFB1;
// bit and bitfield definitions
extern volatile bit TMR3ON              @ ((unsigned)&T3CON*8)+0;
extern volatile bit TMR3CS              @ ((unsigned)&T3CON*8)+1;
extern volatile bit nT3SYNC             @ ((unsigned)&T3CON*8)+2;
extern volatile bit T3CCP1              @ ((unsigned)&T3CON*8)+3;
extern volatile bit T3ECCP1             @ ((unsigned)&T3CON*8)+6;
//extern volatile bit RD16               @ ((unsigned)&T3CON*8)+7;
extern volatile bit T3INSYNC            @ ((unsigned)&T3CON*8)+2;
extern volatile bit T3CKPS0             @ ((unsigned)&T3CON*8)+4;
extern volatile bit T3CKPS1             @ ((unsigned)&T3CON*8)+5;
extern volatile bit T3SYNC              @ ((unsigned)&T3CON*8)+2;
extern union {
    struct {
        volatile unsigned TMR3ON              : 1;
        volatile unsigned TMR3CS              : 1;
        volatile unsigned nT3SYNC             : 1;
        volatile unsigned T3CCP1              : 1;
        volatile unsigned T3CKPS              : 2;
        volatile unsigned T3ECCP1             : 1;
        volatile unsigned RD16                : 1;
    };
    struct {
        volatile unsigned                     : 2;
        volatile unsigned T3INSYNC            : 1;
        volatile unsigned : 1;
        volatile unsigned T3CKPS0             : 1;
        volatile unsigned T3CKPS1             : 1;
        volatile unsigned : 1;
    };
    struct {
        volatile unsigned : 2;
        volatile unsigned T3SYNC              : 1;
    };
} T3CONbits @ 0xFB1;
// bit and bitfield definitions

// Register: TMR3L
extern volatile unsigned char           TMR3L               @ 0xFB2;
// bit and bitfield definitions

// Register: TMR3H
extern volatile unsigned char           TMR3H               @ 0xFB3;
// bit and bitfield definitions

// Register: TMR3
extern volatile unsigned int            TMR3                @ 0xFB2;

// Register: CMCON
extern volatile unsigned char           CMCON               @ 0xFB4;
// bit and bitfield definitions
extern volatile bit CIS                 @ ((unsigned)&CMCON*8)+3;
extern volatile bit C1INV               @ ((unsigned)&CMCON*8)+4;
extern volatile bit C2INV               @ ((unsigned)&CMCON*8)+5;
extern volatile bit C1OUT               @ ((unsigned)&CMCON*8)+6;
extern volatile bit C2OUT               @ ((unsigned)&CMCON*8)+7;
extern volatile bit CM0                 @ ((unsigned)&CMCON*8)+0;
extern volatile bit CM1                 @ ((unsigned)&CMCON*8)+1;
extern volatile bit CM2                 @ ((unsigned)&CMCON*8)+2;
extern union {
    struct {
        volatile unsigned CM                  : 3;
        volatile unsigned CIS                 : 1;
        volatile unsigned C1INV               : 1;
        volatile unsigned C2INV               : 1;
        volatile unsigned C1OUT               : 1;
        volatile unsigned C2OUT               : 1;
    };
    struct {
        volatile unsigned CM0                 : 1;
        volatile unsigned CM1                 : 1;
        volatile unsigned CM2                 : 1;
    };
} CMCONbits @ 0xFB4;

// Register: CVRCON
extern volatile unsigned char           CVRCON              @ 0xFB5;
// bit and bitfield definitions
extern volatile bit CVRSS               @ ((unsigned)&CVRCON*8)+4;
extern volatile bit CVRR                @ ((unsigned)&CVRCON*8)+5;
extern volatile bit CVROE               @ ((unsigned)&CVRCON*8)+6;
extern volatile bit CVREN               @ ((unsigned)&CVRCON*8)+7;
extern volatile bit CVR0                @ ((unsigned)&CVRCON*8)+0;
extern volatile bit CVR1                @ ((unsigned)&CVRCON*8)+1;
extern volatile bit CVR2                @ ((unsigned)&CVRCON*8)+2;
extern volatile bit CVR3                @ ((unsigned)&CVRCON*8)+3;
extern union {
    struct {
        volatile unsigned CVR                 : 4;
        volatile unsigned CVRSS               : 1;
        volatile unsigned CVRR                : 1;
        volatile unsigned CVROE               : 1;
        volatile unsigned CVREN               : 1;
    };
    struct {
        volatile unsigned CVR0                : 1;
        volatile unsigned CVR1                : 1;
        volatile unsigned CVR2                : 1;
        volatile unsigned CVR3                : 1;
    };
} CVRCONbits @ 0xFB5;

// Register: ECCPAS
extern volatile unsigned char           ECCPAS              @ 0xFB6;
// bit and bitfield definitions
extern volatile bit ECCPASE             @ ((unsigned)&ECCPAS*8)+7;
extern volatile bit PSSBD0              @ ((unsigned)&ECCPAS*8)+0;
extern volatile bit PSSBD1              @ ((unsigned)&ECCPAS*8)+1;
extern volatile bit PSSAC0              @ ((unsigned)&ECCPAS*8)+2;
extern volatile bit PSSAC1              @ ((unsigned)&ECCPAS*8)+3;
extern volatile bit ECCPAS0             @ ((unsigned)&ECCPAS*8)+4;
extern volatile bit ECCPAS1             @ ((unsigned)&ECCPAS*8)+5;
extern volatile bit ECCPAS2             @ ((unsigned)&ECCPAS*8)+6;
extern union {
    struct {
        volatile unsigned PSSBD               : 2;
        volatile unsigned PSSAC               : 2;
        volatile unsigned ECCPAS              : 3;
        volatile unsigned ECCPASE             : 1;
    };
    struct {
        volatile unsigned PSSBD0              : 1;
        volatile unsigned PSSBD1              : 1;
        volatile unsigned PSSAC0              : 1;
        volatile unsigned PSSAC1              : 1;
        volatile unsigned ECCPAS0             : 1;
        volatile unsigned ECCPAS1             : 1;
        volatile unsigned ECCPAS2             : 1;
    };
} ECCPASbits @ 0xFB6;

// Register: ECCP1DEL
extern volatile unsigned char           ECCP1DEL            @ 0xFB7;
// bit and bitfield definitions
extern volatile bit EPDC0               @ ((unsigned)&ECCP1DEL*8)+0;
extern volatile bit EPDC1               @ ((unsigned)&ECCP1DEL*8)+1;
extern volatile bit EPDC2               @ ((unsigned)&ECCP1DEL*8)+2;
extern volatile bit EPDC3               @ ((unsigned)&ECCP1DEL*8)+3;
extern volatile bit EPDC4               @ ((unsigned)&ECCP1DEL*8)+4;
extern volatile bit EPDC5               @ ((unsigned)&ECCP1DEL*8)+5;
extern volatile bit EPDC6               @ ((unsigned)&ECCP1DEL*8)+6;
extern volatile bit EPDC7               @ ((unsigned)&ECCP1DEL*8)+7;
extern union {
    struct {
        volatile unsigned EPDC0               : 1;
        volatile unsigned EPDC1               : 1;
        volatile unsigned EPDC2               : 1;
        volatile unsigned EPDC3               : 1;
        volatile unsigned EPDC4               : 1;
        volatile unsigned EPDC5               : 1;
        volatile unsigned EPDC6               : 1;
        volatile unsigned EPDC7               : 1;
    };
} ECCP1DELbits @ 0xFB7;

// Register: ECCP1CON
extern volatile unsigned char           ECCP1CON            @ 0xFBA;
// bit and bitfield definitions
extern volatile bit ECCP1M0             @ ((unsigned)&ECCP1CON*8)+0;
extern volatile bit ECCP1M1             @ ((unsigned)&ECCP1CON*8)+1;
extern volatile bit ECCP1M2             @ ((unsigned)&ECCP1CON*8)+2;
extern volatile bit ECCP1M3             @ ((unsigned)&ECCP1CON*8)+3;
extern volatile bit EDC1B0              @ ((unsigned)&ECCP1CON*8)+4;
extern volatile bit EDC1B1              @ ((unsigned)&ECCP1CON*8)+5;
extern volatile bit EPWM1M0             @ ((unsigned)&ECCP1CON*8)+6;
extern volatile bit EPWM1M1             @ ((unsigned)&ECCP1CON*8)+7;
extern volatile bit EDC2B0              @ ((unsigned)&ECCP1CON*8)+4;
extern volatile bit EDC2B1              @ ((unsigned)&ECCP1CON*8)+5;
extern union {
    struct {
        volatile unsigned ECCP1M              : 4;
        volatile unsigned EDC1B               : 2;
        volatile unsigned EPWM1M              : 2;
    };
    struct {
        volatile unsigned ECCP1M0             : 1;
        volatile unsigned ECCP1M1             : 1;
        volatile unsigned ECCP1M2             : 1;
        volatile unsigned ECCP1M3             : 1;
        volatile unsigned EDC1B0              : 1;
        volatile unsigned EDC1B1              : 1;
        volatile unsigned EPWM1M0             : 1;
        volatile unsigned EPWM1M1             : 1;
    };
    struct {
        volatile unsigned                     : 4;
        volatile unsigned EDC2B0              : 1;
        volatile unsigned EDC2B1              : 1;
    };
} ECCP1CONbits @ 0xFBA;
// bit and bitfield definitions

// Register: ECCPR1L
extern volatile unsigned char           ECCPR1L             @ 0xFBB;
// bit and bitfield definitions

// Register: ECCPR1H
extern volatile unsigned char           ECCPR1H             @ 0xFBC;
// bit and bitfield definitions

// Register: ECCPR1
extern volatile unsigned int            ECCPR1              @ 0xFBB;

// Register: CCP1CON
extern volatile unsigned char           CCP1CON             @ 0xFBD;
// bit and bitfield definitions
extern volatile bit CCP1M0              @ ((unsigned)&CCP1CON*8)+0;
extern volatile bit CCP1M1              @ ((unsigned)&CCP1CON*8)+1;
extern volatile bit CCP1M2              @ ((unsigned)&CCP1CON*8)+2;
extern volatile bit CCP1M3              @ ((unsigned)&CCP1CON*8)+3;
extern volatile bit DC1B0               @ ((unsigned)&CCP1CON*8)+4;
extern volatile bit DC1B1               @ ((unsigned)&CCP1CON*8)+5;
extern volatile bit CCP1Y               @ ((unsigned)&CCP1CON*8)+4;
extern volatile bit CCP1X               @ ((unsigned)&CCP1CON*8)+5;
extern union {
    struct {
        volatile unsigned CCP1M               : 4;
        volatile unsigned DC1B                : 2;
    };
    struct {
        volatile unsigned CCP1M0              : 1;
        volatile unsigned CCP1M1              : 1;
        volatile unsigned CCP1M2              : 1;
        volatile unsigned CCP1M3              : 1;
        volatile unsigned DC1B0               : 1;
        volatile unsigned DC1B1               : 1;
    };
    struct {
        volatile unsigned                     : 4;
        volatile unsigned CCP1Y               : 1;
        volatile unsigned CCP1X               : 1;
    };
} CCP1CONbits @ 0xFBD;
// bit and bitfield definitions

// Register: CCPR1L
extern volatile unsigned char           CCPR1L              @ 0xFBE;
// bit and bitfield definitions

// Register: CCPR1H
extern volatile unsigned char           CCPR1H              @ 0xFBF;
// bit and bitfield definitions

// Register: CCPR1
extern volatile unsigned int            CCPR1               @ 0xFBE;

// Register: ADCON1
extern volatile unsigned char           ADCON1              @ 0xFC1;
// bit and bitfield definitions
extern volatile bit ADCS2               @ ((unsigned)&ADCON1*8)+6;
extern volatile bit ADFM                @ ((unsigned)&ADCON1*8)+7;
extern volatile bit PCFG0               @ ((unsigned)&ADCON1*8)+0;
extern volatile bit PCFG1               @ ((unsigned)&ADCON1*8)+1;
extern volatile bit PCFG2               @ ((unsigned)&ADCON1*8)+2;
extern volatile bit PCFG3               @ ((unsigned)&ADCON1*8)+3;
extern union {
    struct {
        volatile unsigned PCFG                : 4;
        volatile unsigned                     : 2;
        volatile unsigned ADCS2               : 1;
        volatile unsigned ADFM                : 1;
    };
    struct {
        volatile unsigned PCFG0               : 1;
        volatile unsigned PCFG1               : 1;
        volatile unsigned PCFG2               : 1;
        volatile unsigned PCFG3               : 1;
    };
} ADCON1bits @ 0xFC1;

// Register: ADCON0
extern volatile unsigned char           ADCON0              @ 0xFC2;
// bit and bitfield definitions
extern volatile bit ADON                @ ((unsigned)&ADCON0*8)+0;
extern volatile bit GO_nDONE            @ ((unsigned)&ADCON0*8)+2;
extern volatile bit DONE                @ ((unsigned)&ADCON0*8)+2;
extern volatile bit CHS0                @ ((unsigned)&ADCON0*8)+3;
extern volatile bit CHS1                @ ((unsigned)&ADCON0*8)+4;
extern volatile bit CHS2                @ ((unsigned)&ADCON0*8)+5;
extern volatile bit ADCS0               @ ((unsigned)&ADCON0*8)+6;
extern volatile bit ADCS1               @ ((unsigned)&ADCON0*8)+7;
extern volatile bit GO_DONE             @ ((unsigned)&ADCON0*8)+2;
extern volatile bit GO                  @ ((unsigned)&ADCON0*8)+2;
extern volatile bit nDONE               @ ((unsigned)&ADCON0*8)+2;
extern union {
    struct {
        volatile unsigned ADON                : 1;
        volatile unsigned                     : 1;
        volatile unsigned GO_nDONE            : 1;
        volatile unsigned CHS                 : 3;
        volatile unsigned ADCS                : 2;
    };
    struct {
        volatile unsigned : 1;
        volatile unsigned : 1;
        volatile unsigned : 1;
        volatile unsigned : 3;
        volatile unsigned : 2;
    };
    struct {
        volatile unsigned : 2;
        volatile unsigned DONE                : 1;
        volatile unsigned CHS0                : 1;
        volatile unsigned CHS1                : 1;
        volatile unsigned CHS2                : 1;
        volatile unsigned ADCS0               : 1;
        volatile unsigned ADCS1               : 1;
    };
    struct {
        volatile unsigned : 2;
        volatile unsigned GO_DONE             : 1;
    };
    struct {
        volatile unsigned : 2;
        volatile unsigned GO                  : 1;
    };
    struct {
        volatile unsigned : 2;
        volatile unsigned nDONE               : 1;
    };
} ADCON0bits @ 0xFC2;
// bit and bitfield definitions

// Register: ADRESL
extern volatile unsigned char           ADRESL              @ 0xFC3;
// bit and bitfield definitions

// Register: ADRESH
extern volatile unsigned char           ADRESH              @ 0xFC4;
// bit and bitfield definitions

// Register: ADRES
extern volatile unsigned int            ADRES               @ 0xFC3;

// Register: SSPCON2
extern volatile unsigned char           SSPCON2             @ 0xFC5;
// bit and bitfield definitions
extern volatile bit SEN                 @ ((unsigned)&SSPCON2*8)+0;
extern volatile bit RSEN                @ ((unsigned)&SSPCON2*8)+1;
extern volatile bit PEN                 @ ((unsigned)&SSPCON2*8)+2;
extern volatile bit RCEN                @ ((unsigned)&SSPCON2*8)+3;
extern volatile bit ACKEN               @ ((unsigned)&SSPCON2*8)+4;
extern volatile bit ACKDT               @ ((unsigned)&SSPCON2*8)+5;
extern volatile bit ACKSTAT             @ ((unsigned)&SSPCON2*8)+6;
extern volatile bit GCEN                @ ((unsigned)&SSPCON2*8)+7;
extern union {
    struct {
        volatile unsigned SEN                 : 1;
        volatile unsigned RSEN                : 1;
        volatile unsigned PEN                 : 1;
        volatile unsigned RCEN                : 1;
        volatile unsigned ACKEN               : 1;
        volatile unsigned ACKDT               : 1;
        volatile unsigned ACKSTAT             : 1;
        volatile unsigned GCEN                : 1;
    };
} SSPCON2bits @ 0xFC5;

// Register: SSPCON1
extern volatile unsigned char           SSPCON1             @ 0xFC6;
// bit and bitfield definitions
extern volatile bit CKP                 @ ((unsigned)&SSPCON1*8)+4;
extern volatile bit SSPEN               @ ((unsigned)&SSPCON1*8)+5;
extern volatile bit SSPOV               @ ((unsigned)&SSPCON1*8)+6;
extern volatile bit WCOL                @ ((unsigned)&SSPCON1*8)+7;
extern volatile bit SSPM0               @ ((unsigned)&SSPCON1*8)+0;
extern volatile bit SSPM1               @ ((unsigned)&SSPCON1*8)+1;
extern volatile bit SSPM2               @ ((unsigned)&SSPCON1*8)+2;
extern volatile bit SSPM3               @ ((unsigned)&SSPCON1*8)+3;
extern union {
    struct {
        volatile unsigned SSPM                : 4;
        volatile unsigned CKP                 : 1;
        volatile unsigned SSPEN               : 1;
        volatile unsigned SSPOV               : 1;
        volatile unsigned WCOL                : 1;
    };
    struct {
        volatile unsigned SSPM0               : 1;
        volatile unsigned SSPM1               : 1;
        volatile unsigned SSPM2               : 1;
        volatile unsigned SSPM3               : 1;
    };
} SSPCON1bits @ 0xFC6;

// Register: SSPSTAT
extern volatile unsigned char           SSPSTAT             @ 0xFC7;
// bit and bitfield definitions
extern volatile bit BF                  @ ((unsigned)&SSPSTAT*8)+0;
extern volatile bit UA                  @ ((unsigned)&SSPSTAT*8)+1;
extern volatile bit R_nW                @ ((unsigned)&SSPSTAT*8)+2;
extern volatile bit S                   @ ((unsigned)&SSPSTAT*8)+3;
extern volatile bit P                   @ ((unsigned)&SSPSTAT*8)+4;
extern volatile bit D_nA                @ ((unsigned)&SSPSTAT*8)+5;
extern volatile bit CKE                 @ ((unsigned)&SSPSTAT*8)+6;
extern volatile bit SMP                 @ ((unsigned)&SSPSTAT*8)+7;
extern volatile bit I2C_READ            @ ((unsigned)&SSPSTAT*8)+2;
extern volatile bit I2C_START           @ ((unsigned)&SSPSTAT*8)+3;
extern volatile bit I2C_STOP            @ ((unsigned)&SSPSTAT*8)+4;
extern volatile bit I2C_DATA            @ ((unsigned)&SSPSTAT*8)+5;
extern volatile bit R                   @ ((unsigned)&SSPSTAT*8)+2;
extern volatile bit D                   @ ((unsigned)&SSPSTAT*8)+5;
extern volatile bit READ_WRITE          @ ((unsigned)&SSPSTAT*8)+2;
extern volatile bit DATA_ADDRESS        @ ((unsigned)&SSPSTAT*8)+5;
extern volatile bit nWRITE              @ ((unsigned)&SSPSTAT*8)+2;
extern volatile bit nADDRESS            @ ((unsigned)&SSPSTAT*8)+5;
extern volatile bit nW                  @ ((unsigned)&SSPSTAT*8)+2;
extern volatile bit nA                  @ ((unsigned)&SSPSTAT*8)+5;
extern volatile bit R_W                 @ ((unsigned)&SSPSTAT*8)+2;
extern volatile bit D_A                 @ ((unsigned)&SSPSTAT*8)+5;
extern volatile bit I2C_DAT             @ ((unsigned)&SSPSTAT*8)+5;
extern union {
    struct {
        volatile unsigned BF                  : 1;
        volatile unsigned UA                  : 1;
        volatile unsigned R_nW                : 1;
        volatile unsigned S                   : 1;
        volatile unsigned P                   : 1;
        volatile unsigned D_nA                : 1;
        volatile unsigned CKE                 : 1;
        volatile unsigned SMP                 : 1;
    };
    struct {
        volatile unsigned : 1;
        volatile unsigned : 1;
        volatile unsigned : 1;
        volatile unsigned : 1;
        volatile unsigned : 1;
        volatile unsigned : 1;
        volatile unsigned : 1;
        volatile unsigned : 1;
    };
    struct {
        volatile unsigned                     : 2;
        volatile unsigned I2C_READ            : 1;
        volatile unsigned I2C_START           : 1;
        volatile unsigned I2C_STOP            : 1;
        volatile unsigned I2C_DATA            : 1;
    };
    struct {
        volatile unsigned : 2;
        volatile unsigned R                   : 1;
        volatile unsigned : 2;
        volatile unsigned D                   : 1;
    };
    struct {
        volatile unsigned : 2;
        volatile unsigned READ_WRITE          : 1;
        volatile unsigned : 2;
        volatile unsigned DATA_ADDRESS        : 1;
    };
    struct {
        volatile unsigned : 2;
        volatile unsigned nWRITE              : 1;
        volatile unsigned : 2;
        volatile unsigned nADDRESS            : 1;
    };
    struct {
        volatile unsigned : 2;
        volatile unsigned nW                  : 1;
        volatile unsigned : 2;
        volatile unsigned nA                  : 1;
    };
    struct {
        volatile unsigned : 2;
        volatile unsigned R_W                 : 1;
        volatile unsigned : 2;
        volatile unsigned D_A                 : 1;
    };
    struct {
        volatile unsigned : 5;
        volatile unsigned I2C_DAT             : 1;
    };
} SSPSTATbits @ 0xFC7;

// Register: SSPADD
extern volatile unsigned char           SSPADD              @ 0xFC8;
// bit and bitfield definitions

// Register: SSPBUF
extern volatile unsigned char           SSPBUF              @ 0xFC9;
// bit and bitfield definitions

// Register: T2CON
extern volatile unsigned char           T2CON               @ 0xFCA;
// bit and bitfield definitions
extern volatile bit TMR2ON              @ ((unsigned)&T2CON*8)+2;
extern volatile bit T2CKPS0             @ ((unsigned)&T2CON*8)+0;
extern volatile bit T2CKPS1             @ ((unsigned)&T2CON*8)+1;
extern volatile bit TOUTPS0             @ ((unsigned)&T2CON*8)+3;
extern volatile bit TOUTPS1             @ ((unsigned)&T2CON*8)+4;
extern volatile bit TOUTPS2             @ ((unsigned)&T2CON*8)+5;
extern volatile bit TOUTPS3             @ ((unsigned)&T2CON*8)+6;
extern union {
    struct {
        volatile unsigned T2CKPS              : 2;
        volatile unsigned TMR2ON              : 1;
        volatile unsigned TOUTPS              : 4;
    };
    struct {
        volatile unsigned T2CKPS0             : 1;
        volatile unsigned T2CKPS1             : 1;
        volatile unsigned                     : 1;
        volatile unsigned TOUTPS0             : 1;
        volatile unsigned TOUTPS1             : 1;
        volatile unsigned TOUTPS2             : 1;
        volatile unsigned TOUTPS3             : 1;
    };
} T2CONbits @ 0xFCA;

// Register: PR2
extern volatile unsigned char           PR2                 @ 0xFCB;
// bit and bitfield definitions

// Register: TMR2
extern volatile unsigned char           TMR2                @ 0xFCC;
// bit and bitfield definitions

// Register: T1CON
extern volatile unsigned char           T1CON               @ 0xFCD;
// bit and bitfield definitions
extern volatile bit TMR1ON              @ ((unsigned)&T1CON*8)+0;
extern volatile bit TMR1CS              @ ((unsigned)&T1CON*8)+1;
extern volatile bit nT1SYNC             @ ((unsigned)&T1CON*8)+2;
extern volatile bit T1OSCEN             @ ((unsigned)&T1CON*8)+3;
//extern volatile bit RD16               @ ((unsigned)&T1CON*8)+7;
extern volatile bit T1INSYNC            @ ((unsigned)&T1CON*8)+2;
extern volatile bit T1CKPS0             @ ((unsigned)&T1CON*8)+4;
extern volatile bit T1CKPS1             @ ((unsigned)&T1CON*8)+5;
extern volatile bit T1SYNC              @ ((unsigned)&T1CON*8)+2;
extern union {
    struct {
        volatile unsigned TMR1ON              : 1;
        volatile unsigned TMR1CS              : 1;
        volatile unsigned nT1SYNC             : 1;
        volatile unsigned T1OSCEN             : 1;
        volatile unsigned T1CKPS              : 2;
        volatile unsigned                     : 1;
        volatile unsigned RD16                : 1;
    };
    struct {
        volatile unsigned : 2;
        volatile unsigned T1INSYNC            : 1;
        volatile unsigned : 1;
        volatile unsigned T1CKPS0             : 1;
        volatile unsigned T1CKPS1             : 1;
    };
    struct {
        volatile unsigned : 2;
        volatile unsigned T1SYNC              : 1;
    };
} T1CONbits @ 0xFCD;
// bit and bitfield definitions

// Register: TMR1L
extern volatile unsigned char           TMR1L               @ 0xFCE;
// bit and bitfield definitions

// Register: TMR1H
extern volatile unsigned char           TMR1H               @ 0xFCF;
// bit and bitfield definitions

// Register: TMR1
extern volatile unsigned int            TMR1                @ 0xFCE;

// Register: RCON
extern volatile unsigned char           RCON                @ 0xFD0;
// bit and bitfield definitions
extern volatile bit nBOR                @ ((unsigned)&RCON*8)+0;
extern volatile bit nPOR                @ ((unsigned)&RCON*8)+1;
extern volatile bit nPD                 @ ((unsigned)&RCON*8)+2;
extern volatile bit nTO                 @ ((unsigned)&RCON*8)+3;
extern volatile bit nRI                 @ ((unsigned)&RCON*8)+4;
extern volatile bit IPEN                @ ((unsigned)&RCON*8)+7;
extern volatile bit BOR                 @ ((unsigned)&RCON*8)+0;
extern volatile bit POR                 @ ((unsigned)&RCON*8)+1;
extern volatile bit PD                  @ ((unsigned)&RCON*8)+2;
extern volatile bit TO                  @ ((unsigned)&RCON*8)+3;
extern volatile bit RI                  @ ((unsigned)&RCON*8)+4;
extern volatile bit nIPEN               @ ((unsigned)&RCON*8)+7;
extern union {
    struct {
        volatile unsigned nBOR                : 1;
        volatile unsigned nPOR                : 1;
        volatile unsigned nPD                 : 1;
        volatile unsigned nTO                 : 1;
        volatile unsigned nRI                 : 1;
        volatile unsigned                     : 2;
        volatile unsigned IPEN                : 1;
    };
    struct {
        volatile unsigned BOR                 : 1;
        volatile unsigned POR                 : 1;
        volatile unsigned PD                  : 1;
        volatile unsigned TO                  : 1;
        volatile unsigned RI                  : 1;
        volatile unsigned : 2;
        volatile unsigned nIPEN               : 1;
    };
} RCONbits @ 0xFD0;

// Register: WDTCON
extern volatile unsigned char           WDTCON              @ 0xFD1;
// bit and bitfield definitions
extern volatile bit SWDTEN              @ ((unsigned)&WDTCON*8)+0;
extern volatile bit SWDTE               @ ((unsigned)&WDTCON*8)+0;
extern union {
    struct {
        volatile unsigned SWDTEN              : 1;
    };
    struct {
        volatile unsigned SWDTE               : 1;
    };
} WDTCONbits @ 0xFD1;

// Register: LVDCON
extern volatile unsigned char           LVDCON              @ 0xFD2;
// bit and bitfield definitions
extern volatile bit LVDEN               @ ((unsigned)&LVDCON*8)+4;
extern volatile bit IRVST               @ ((unsigned)&LVDCON*8)+5;
extern volatile bit LVDL0               @ ((unsigned)&LVDCON*8)+0;
extern volatile bit LVDL1               @ ((unsigned)&LVDCON*8)+1;
extern volatile bit LVDL2               @ ((unsigned)&LVDCON*8)+2;
extern volatile bit LVDL3               @ ((unsigned)&LVDCON*8)+3;
extern volatile bit IVRST               @ ((unsigned)&LVDCON*8)+5;
extern union {
    struct {
        volatile unsigned LVDL                : 4;
        volatile unsigned LVDEN               : 1;
        volatile unsigned IRVST               : 1;
    };
    struct {
        volatile unsigned LVDL0               : 1;
        volatile unsigned LVDL1               : 1;
        volatile unsigned LVDL2               : 1;
        volatile unsigned LVDL3               : 1;
        volatile unsigned                     : 1;
        volatile unsigned IVRST               : 1;
    };
} LVDCONbits @ 0xFD2;

// Register: OSCCON
extern volatile unsigned char           OSCCON              @ 0xFD3;
// bit and bitfield definitions
extern volatile bit SCS                 @ ((unsigned)&OSCCON*8)+0;
extern union {
    struct {
        volatile unsigned SCS                 : 1;
    };
} OSCCONbits @ 0xFD3;

// Register: T0CON
extern volatile unsigned char           T0CON               @ 0xFD5;
// bit and bitfield definitions
extern volatile bit PSA                 @ ((unsigned)&T0CON*8)+3;
extern volatile bit T0SE                @ ((unsigned)&T0CON*8)+4;
extern volatile bit T0CS                @ ((unsigned)&T0CON*8)+5;
extern volatile bit T08BIT              @ ((unsigned)&T0CON*8)+6;
extern volatile bit TMR0ON              @ ((unsigned)&T0CON*8)+7;
extern volatile bit T0PS0               @ ((unsigned)&T0CON*8)+0;
extern volatile bit T0PS1               @ ((unsigned)&T0CON*8)+1;
extern volatile bit T0PS2               @ ((unsigned)&T0CON*8)+2;
extern union {
    struct {
        volatile unsigned T0PS                : 3;
        volatile unsigned PSA                 : 1;
        volatile unsigned T0SE                : 1;
        volatile unsigned T0CS                : 1;
        volatile unsigned T08BIT              : 1;
        volatile unsigned TMR0ON              : 1;
    };
    struct {
        volatile unsigned T0PS0               : 1;
        volatile unsigned T0PS1               : 1;
        volatile unsigned T0PS2               : 1;
    };
} T0CONbits @ 0xFD5;
// bit and bitfield definitions

// Register: TMR0L
extern volatile unsigned char           TMR0L               @ 0xFD6;
// bit and bitfield definitions

// Register: TMR0H
extern volatile unsigned char           TMR0H               @ 0xFD7;
// bit and bitfield definitions

// Register: TMR0
extern volatile unsigned int            TMR0                @ 0xFD6;

// Register: STATUS
extern volatile unsigned char           STATUS              @ 0xFD8;
// bit and bitfield definitions
extern volatile bit CARRY               @ ((unsigned)&STATUS*8)+0;
extern volatile bit DC                  @ ((unsigned)&STATUS*8)+1;
extern volatile bit ZERO                @ ((unsigned)&STATUS*8)+2;
extern volatile bit OV                  @ ((unsigned)&STATUS*8)+3;
extern volatile bit N                   @ ((unsigned)&STATUS*8)+4;
extern union {
    struct {
        volatile unsigned C                   : 1;
        volatile unsigned DC                  : 1;
        volatile unsigned Z                   : 1;
        volatile unsigned OV                  : 1;
        volatile unsigned N                   : 1;
    };
} STATUSbits @ 0xFD8;
// bit and bitfield definitions

// Register: FSR2L
extern volatile unsigned char           FSR2L               @ 0xFD9;
// bit and bitfield definitions

// Register: FSR2H
extern volatile unsigned char           FSR2H               @ 0xFDA;
// bit and bitfield definitions
extern union {
    struct {
        volatile unsigned                     : 4;
    };
} FSR2Hbits @ 0xFDA;

// Register: FSR2
extern volatile unsigned int            FSR2                @ 0xFD9;

// Register: PLUSW2
extern volatile unsigned char           PLUSW2              @ 0xFDB;
// bit and bitfield definitions

// Register: PREINC2
extern volatile unsigned char           PREINC2             @ 0xFDC;
// bit and bitfield definitions

// Register: POSTDEC2
extern volatile unsigned char           POSTDEC2            @ 0xFDD;
// bit and bitfield definitions

// Register: POSTINC2
extern volatile unsigned char           POSTINC2            @ 0xFDE;
// bit and bitfield definitions

// Register: INDF2
extern volatile unsigned char           INDF2               @ 0xFDF;
// bit and bitfield definitions

// Register: BSR
extern volatile unsigned char           BSR                 @ 0xFE0;
// bit and bitfield definitions
extern union {
    struct {
        volatile unsigned                     : 4;
    };
} BSRbits @ 0xFE0;
// bit and bitfield definitions

// Register: FSR1L
extern volatile unsigned char           FSR1L               @ 0xFE1;
// bit and bitfield definitions

// Register: FSR1H
extern volatile unsigned char           FSR1H               @ 0xFE2;
// bit and bitfield definitions
extern union {
    struct {
        volatile unsigned                     : 4;
    };
} FSR1Hbits @ 0xFE2;

// Register: FSR1
extern volatile unsigned int            FSR1                @ 0xFE1;

// Register: PLUSW1
extern volatile unsigned char           PLUSW1              @ 0xFE3;
// bit and bitfield definitions

// Register: PREINC1
extern volatile unsigned char           PREINC1             @ 0xFE4;
// bit and bitfield definitions

// Register: POSTDEC1
extern volatile unsigned char           POSTDEC1            @ 0xFE5;
// bit and bitfield definitions

// Register: POSTINC1
extern volatile unsigned char           POSTINC1            @ 0xFE6;
// bit and bitfield definitions

// Register: INDF1
extern volatile unsigned char           INDF1               @ 0xFE7;
// bit and bitfield definitions

// Register: WREG
extern volatile unsigned char           WREG                @ 0xFE8;
extern volatile unsigned char           W                   @ 0xFE8;
// bit and bitfield definitions
// bit and bitfield definitions

// Register: FSR0L
extern volatile unsigned char           FSR0L               @ 0xFE9;
// bit and bitfield definitions

// Register: FSR0H
extern volatile unsigned char           FSR0H               @ 0xFEA;
// bit and bitfield definitions
extern union {
    struct {
        volatile unsigned                     : 4;
    };
} FSR0Hbits @ 0xFEA;

// Register: FSR0
extern volatile unsigned int            FSR0                @ 0xFE9;

// Register: PLUSW0
extern volatile unsigned char           PLUSW0              @ 0xFEB;
// bit and bitfield definitions

// Register: PREINC0
extern volatile unsigned char           PREINC0             @ 0xFEC;
// bit and bitfield definitions

// Register: POSTDEC0
extern volatile unsigned char           POSTDEC0            @ 0xFED;
// bit and bitfield definitions

// Register: POSTINC0
extern volatile unsigned char           POSTINC0            @ 0xFEE;
// bit and bitfield definitions

// Register: INDF0
extern volatile unsigned char           INDF0               @ 0xFEF;
// bit and bitfield definitions

// Register: INTCON3
extern volatile unsigned char           INTCON3             @ 0xFF0;
// bit and bitfield definitions
extern volatile bit INT1IF              @ ((unsigned)&INTCON3*8)+0;
extern volatile bit INT2IF              @ ((unsigned)&INTCON3*8)+1;
extern volatile bit INT1IE              @ ((unsigned)&INTCON3*8)+3;
extern volatile bit INT2IE              @ ((unsigned)&INTCON3*8)+4;
extern volatile bit INT1IP              @ ((unsigned)&INTCON3*8)+6;
extern volatile bit INT2IP              @ ((unsigned)&INTCON3*8)+7;
extern volatile bit INT1F               @ ((unsigned)&INTCON3*8)+0;
extern volatile bit INT2F               @ ((unsigned)&INTCON3*8)+1;
extern volatile bit INT1E               @ ((unsigned)&INTCON3*8)+3;
extern volatile bit INT2E               @ ((unsigned)&INTCON3*8)+4;
extern volatile bit INT1P               @ ((unsigned)&INTCON3*8)+6;
extern volatile bit INT2P               @ ((unsigned)&INTCON3*8)+7;
extern union {
    struct {
        volatile unsigned INT1IF              : 1;
        volatile unsigned INT2IF              : 1;
        volatile unsigned                     : 1;
        volatile unsigned INT1IE              : 1;
        volatile unsigned INT2IE              : 1;
        volatile unsigned : 1;
        volatile unsigned INT1IP              : 1;
        volatile unsigned INT2IP              : 1;
    };
    struct {
        volatile unsigned INT1F               : 1;
        volatile unsigned INT2F               : 1;
        volatile unsigned : 1;
        volatile unsigned INT1E               : 1;
        volatile unsigned INT2E               : 1;
        volatile unsigned : 1;
        volatile unsigned INT1P               : 1;
        volatile unsigned INT2P               : 1;
    };
} INTCON3bits @ 0xFF0;

// Register: INTCON2
extern volatile unsigned char           INTCON2             @ 0xFF1;
// bit and bitfield definitions
extern volatile bit RBIP                @ ((unsigned)&INTCON2*8)+0;
extern volatile bit TMR0IP              @ ((unsigned)&INTCON2*8)+2;
extern volatile bit INTEDG2             @ ((unsigned)&INTCON2*8)+4;
extern volatile bit INTEDG1             @ ((unsigned)&INTCON2*8)+5;
extern volatile bit INTEDG0             @ ((unsigned)&INTCON2*8)+6;
extern volatile bit nRBPU               @ ((unsigned)&INTCON2*8)+7;
extern volatile bit T0IP                @ ((unsigned)&INTCON2*8)+2;
extern volatile bit RBPU                @ ((unsigned)&INTCON2*8)+7;
extern union {
    struct {
        volatile unsigned RBIP                : 1;
        volatile unsigned                     : 1;
        volatile unsigned TMR0IP              : 1;
        volatile unsigned : 1;
        volatile unsigned INTEDG2             : 1;
        volatile unsigned INTEDG1             : 1;
        volatile unsigned INTEDG0             : 1;
        volatile unsigned nRBPU               : 1;
    };
    struct {
        volatile unsigned : 2;
        volatile unsigned T0IP                : 1;
        volatile unsigned : 4;
        volatile unsigned RBPU                : 1;
    };
} INTCON2bits @ 0xFF1;

// Register: INTCON
extern volatile unsigned char           INTCON              @ 0xFF2;
extern volatile unsigned char           INTCON1             @ 0xFF2;
// bit and bitfield definitions
extern volatile bit RBIF                @ ((unsigned)&INTCON*8)+0;
extern volatile bit INT0IF              @ ((unsigned)&INTCON*8)+1;
extern volatile bit TMR0IF              @ ((unsigned)&INTCON*8)+2;
extern volatile bit RBIE                @ ((unsigned)&INTCON*8)+3;
extern volatile bit INT0IE              @ ((unsigned)&INTCON*8)+4;
extern volatile bit TMR0IE              @ ((unsigned)&INTCON*8)+5;
extern volatile bit PEIE_GIEL           @ ((unsigned)&INTCON*8)+6;
extern volatile bit GIE_GIEH            @ ((unsigned)&INTCON*8)+7;
extern volatile bit PEIE                @ ((unsigned)&INTCON*8)+6;
extern volatile bit GIE                 @ ((unsigned)&INTCON*8)+7;
extern volatile bit GIEL                @ ((unsigned)&INTCON*8)+6;
extern volatile bit GIEH                @ ((unsigned)&INTCON*8)+7;
extern volatile bit INT0F               @ ((unsigned)&INTCON*8)+1;
extern volatile bit T0IF                @ ((unsigned)&INTCON*8)+2;
extern volatile bit INT0E               @ ((unsigned)&INTCON*8)+4;
extern volatile bit T0IE                @ ((unsigned)&INTCON*8)+5;
extern union {
    struct {
        volatile unsigned RBIF                : 1;
        volatile unsigned INT0IF              : 1;
        volatile unsigned TMR0IF              : 1;
        volatile unsigned RBIE                : 1;
        volatile unsigned INT0IE              : 1;
        volatile unsigned TMR0IE              : 1;
        volatile unsigned PEIE_GIEL           : 1;
        volatile unsigned GIE_GIEH            : 1;
    };
    struct {
        volatile unsigned : 1;
        volatile unsigned : 1;
        volatile unsigned : 1;
        volatile unsigned : 1;
        volatile unsigned : 1;
        volatile unsigned : 1;
        volatile unsigned PEIE                : 1;
        volatile unsigned GIE                 : 1;
    };
    struct {
        volatile unsigned : 1;
        volatile unsigned : 1;
        volatile unsigned : 1;
        volatile unsigned : 1;
        volatile unsigned : 1;
        volatile unsigned : 1;
        volatile unsigned GIEL                : 1;
        volatile unsigned GIEH                : 1;
    };
    struct {
        volatile unsigned : 1;
        volatile unsigned : 1;
        volatile unsigned : 1;
        volatile unsigned : 1;
        volatile unsigned : 1;
        volatile unsigned : 1;
        volatile unsigned : 1;
        volatile unsigned : 1;
    };
    struct {
        volatile unsigned                     : 1;
        volatile unsigned INT0F               : 1;
        volatile unsigned T0IF                : 1;
        volatile unsigned : 1;
        volatile unsigned INT0E               : 1;
        volatile unsigned T0IE                : 1;
        volatile unsigned : 1;
        volatile unsigned : 1;
    };
    struct {
        volatile unsigned : 6;
        volatile unsigned : 1;
        volatile unsigned : 1;
    };
} INTCONbits @ 0xFF2;
// bit and bitfield definitions

// Register: PRODL
extern volatile unsigned char           PRODL               @ 0xFF3;
// bit and bitfield definitions

// Register: PRODH
extern volatile unsigned char           PRODH               @ 0xFF4;
// bit and bitfield definitions

// Register: PROD
extern volatile unsigned int            PROD                @ 0xFF3;

// Register: TABLAT
extern volatile unsigned char           TABLAT              @ 0xFF5;
// bit and bitfield definitions
// bit and bitfield definitions

// Register: TBLPTRL
extern volatile unsigned char           TBLPTRL             @ 0xFF6;
// bit and bitfield definitions

// Register: TBLPTRH
extern volatile unsigned char           TBLPTRH             @ 0xFF7;
// bit and bitfield definitions

// Register: TBLPTRU
extern volatile unsigned char           TBLPTRU             @ 0xFF8;
// bit and bitfield definitions
extern union {
    struct {
        volatile unsigned                     : 5;
        volatile unsigned : 1;
    };
} TBLPTRUbits @ 0xFF8;

// Register: TBLPTR
extern volatile far unsigned char * TBLPTR              @ 0xFF6;
// bit and bitfield definitions

// Register: PCL
extern volatile unsigned char           PCL                 @ 0xFF9;
// bit and bitfield definitions

// Register: PCLATH
extern volatile unsigned char           PCLATH              @ 0xFFA;
// bit and bitfield definitions

// Register: PCLATU
extern volatile unsigned char           PCLATU              @ 0xFFB;
// bit and bitfield definitions
extern union {
    struct {
        volatile unsigned                     : 5;
    };
} PCLATUbits @ 0xFFB;

// Register: PCLAT
extern volatile unsigned short long int PCLAT               @ 0xFF9;

// Register: STKPTR
extern volatile unsigned char           STKPTR              @ 0xFFC;
// bit and bitfield definitions
extern volatile bit STKUNF              @ ((unsigned)&STKPTR*8)+6;
extern volatile bit STKFUL              @ ((unsigned)&STKPTR*8)+7;
extern volatile bit STKPTR0             @ ((unsigned)&STKPTR*8)+0;
extern volatile bit STKPTR1             @ ((unsigned)&STKPTR*8)+1;
extern volatile bit STKPTR2             @ ((unsigned)&STKPTR*8)+2;
extern volatile bit STKPTR3             @ ((unsigned)&STKPTR*8)+3;
extern volatile bit STKPTR4             @ ((unsigned)&STKPTR*8)+4;
extern volatile bit STKOVF              @ ((unsigned)&STKPTR*8)+7;
extern volatile bit SP0                 @ ((unsigned)&STKPTR*8)+0;
extern volatile bit SP1                 @ ((unsigned)&STKPTR*8)+1;
extern volatile bit SP2                 @ ((unsigned)&STKPTR*8)+2;
extern volatile bit SP3                 @ ((unsigned)&STKPTR*8)+3;
extern volatile bit SP4                 @ ((unsigned)&STKPTR*8)+4;
extern union {
    struct {
        volatile unsigned STKPTR              : 5;
        volatile unsigned                     : 1;
        volatile unsigned STKUNF              : 1;
        volatile unsigned STKFUL              : 1;
    };
    struct {
        volatile unsigned STKPTR0             : 1;
        volatile unsigned STKPTR1             : 1;
        volatile unsigned STKPTR2             : 1;
        volatile unsigned STKPTR3             : 1;
        volatile unsigned STKPTR4             : 1;
        volatile unsigned : 2;
        volatile unsigned STKOVF              : 1;
    };
    struct {
        volatile unsigned SP0                 : 1;
        volatile unsigned SP1                 : 1;
        volatile unsigned SP2                 : 1;
        volatile unsigned SP3                 : 1;
        volatile unsigned SP4                 : 1;
    };
} STKPTRbits @ 0xFFC;
// bit and bitfield definitions

// Register: TOSL
extern volatile unsigned char           TOSL                @ 0xFFD;
// bit and bitfield definitions

// Register: TOSH
extern volatile unsigned char           TOSH                @ 0xFFE;
// bit and bitfield definitions

// Register: TOSU
extern volatile unsigned char           TOSU                @ 0xFFF;
// bit and bitfield definitions
extern union {
    struct {
        volatile unsigned                     : 5;
    };
} TOSUbits @ 0xFFF;

// Register: TOS
extern volatile unsigned short long int TOS                 @ 0xFFD;

// Register: TMR0_Internal
extern volatile unsigned int            TMR0_Internal       @ 0x1000;
// bit and bitfield definitions
extern union {
    struct {
        volatile unsigned InternalTMR         : 16;
    };
} TMR0_Internalbits @ 0x1000;

// Register: TMR0_Prescale
extern volatile unsigned char           TMR0_Prescale       @ 0x1002;
// bit and bitfield definitions

// Register: TMR1_Internal
extern volatile unsigned int            TMR1_Internal       @ 0x1003;
// bit and bitfield definitions
extern union {
    struct {
        volatile unsigned InternalTMR         : 16;
    };
} TMR1_Internalbits @ 0x1003;

// Register: TMR1_Prescale
extern volatile unsigned char           TMR1_Prescale       @ 0x1005;
// bit and bitfield definitions

// Register: TMR2_Prescale
extern volatile unsigned char           TMR2_Prescale       @ 0x1006;
// bit and bitfield definitions

// Register: TMR3_Internal
extern volatile unsigned int            TMR3_Internal       @ 0x1007;
// bit and bitfield definitions
extern union {
    struct {
        volatile unsigned InternalTMR         : 16;
    };
} TMR3_Internalbits @ 0x1007;

// Register: TMR3_Prescale
extern volatile unsigned char           TMR3_Prescale       @ 0x1009;
// bit and bitfield definitions


#endif

Make sure you use the MPLAB Project Wizard and select the correct device before you begin coding. Otherwise the correct device specific header file will not be included and register names like TMR0L will not be recognized.

BigDog

2010ee179 · Apr 2, 2012

Thanks....

Welcome to EDAboard.com

pic18f458 header file problem

2010ee179

Member level 2

bigdogguru

Administrator

2010ee179

2010ee179

Member level 2

Similar threads

Part and Inventory Search

Welcome to EDABoard.com

Sponsor

Connect with us

Online statistics

Forum statistics