PIC18f2680 with MPLAB using C

marven2320 · Jul 26, 2012

I am new to PIC18 series. And I'm having difficulties regarding PIC18f2680 in MPLAB using C compiler.
Can anybody help me with a short sample for:

Input/Output PORT settings
-I am configuring PORTA as digital INPUT while PORTC as digital output.
Serial UART
-Sample UART syntax

Any help will be much appreciated!
Thanks!

bmandl · Jul 26, 2012

Well, for ports direction, just clear PORTx, if you want to set it as output (example: PORTC=0), and you must set PORTx if you wish to set it as input (example: PORTA=255).
For UART, you will have to tell, which compiler are you using. If you have Hitech C compiler, there is already example code for UART included.

marven2320 · Jul 26, 2012

I am using Hitech C Compiler.
How to disable Analog Input since PortA can also be configured as analog input?
I want to detect if portA.f0 is trigged by setting portc.f0 equal to 1 but my code didnt work well.

bigdogguru · Jul 26, 2012

marven2320 said:
I am using Hitech C Compiler.
How to disable Analog Input since PortA can also be configured as analog input?

Typically the required procedure is covered in the devices datasheet.

Reference: PIC18F2585/2680/4585/4680 Datasheet, Section: 10.1 PORTA, TRISA and LATA Registers, Page: 129

10.1 PORTA, TRISA and LATA Registers

PORTA is an 8-bit wide, bidirectional port. The
corresponding data direction register is TRISA. Setting
a TRISA bit (= 1) will make the corresponding PORTA
pin an input (i.e., put the corresponding output driver in
a high-impedance mode). Clearing a TRISA bit (= 0)
will make the corresponding PORTA pin an output (i.e.,
put the contents of the output latch on the selected pin).

Reading the PORTA register reads the status of the
pins, whereas writing to it, will write to the port latch.

The Data Latch register (LATA) is also memory
mapped. Read-modify-write operations on the LATA
register read and write the latched output value for
PORTA.

The RA4 pin is multiplexed with the Timer0 module
clock input to become the RA4/T0CKI pin. Pins RA6
and RA7 are multiplexed with the main oscillator pins;
they are enabled as oscillator or I/O pins by the selection
of the main oscillator in Configuration Register 1H
(see Section 24.1 “Configuration Bits” for details).
When they are not used as port pins, RA6 and RA7 and
their associated TRIS and LAT bits are read as ‘0’.

The other PORTA pins are multiplexed with analog
inputs, the analog VREF+ and VREF- inputs and the
comparator voltage reference output. The operation of
pins RA3:RA0 and RA5 as A/D converter inputs is
selected by clearing/setting the control bits in the
ADCON1 register (A/D Control Register 1).

Note:
On a Power-on Reset, RA5 and RA3:RA0
are configured as analog inputs and read
as ‘0’. RA4 is configured as a digital input.

All other PORTA pins have TTL input levels and full
CMOS output drivers.

The TRISA register controls the direction of the RA
pins, even when they are being used as analog inputs.
The user must ensure the bits in the TRISA register are
maintained set when using them as analog inputs.

Procedure Demonstrated in Assembly:
EXAMPLE 10-1: INITIALIZING PORTA

Code:

CLRF PORTA ; Initialize PORTA by
                 ; clearing output
                 ; data latches
CLRF LATA  ; Alternate method
                ; to clear output
                ; data latches
MOVLW 0Fh ; Configure A/D
MOVWF ADCON1 ; for digital inputs
MOVWF 07h ; Configure comparators
MOVWF CMCON ; for digital input
MOVLW 0CFh ; Value used to
                  ; initialize data
                  ; direction
MOVWF TRISA ; Set RA<3:0> as inputs
                    ; RA<5:4> as outputs

Reference the device specific header of your compiler for the appropriate register names:

pic18f2680.h

Code:

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

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

#ifndef __PIC18F2680_H
#define __PIC18F2680_H

#include <peripheral/pconfig.h>

// Config Register: CONFIG1H
// Oscillator Selection bits
// Internal oscillator block, CLKO function on RA6, port function on RA7
#define OSC_IRCIO7           0xF1FF 
// Internal oscillator block, port function on RA6 and RA7
#define OSC_IRCIO67          0xF0FF 
// External RC oscillator, port function on RA6
#define OSC_RCIO             0xFFFF 
// HS oscillator, PLL enabled (Clock Frequency = 4 x FOSC1)
#define OSC_HSPLL            0xFEFF 
// EC oscillator, port function on RA6
#define OSC_ECIO             0xFDFF 
// EC oscillator, CLKO function on RA6
#define OSC_EC               0xFCFF 
// External RC oscillator, CLKO function on RA6
#define OSC_RC               0xFBFF 
// HS oscillator
#define OSC_HS               0xFAFF 
// XT oscillator
#define OSC_XT               0xF9FF 
// LP oscillator
#define OSC_LP               0xF8FF 
// Fail-Safe Clock Monitor Enable bit
// Fail-Safe Clock Monitor enabled
#define FCMEN_ON             0xBFFF 
// Fail-Safe Clock Monitor disabled
#define FCMEN_OFF            0xFFFF 
// Internal/External Oscillator Switchover bit
// Oscillator Switchover mode enabled
#define IESO_ON              0x7FFF 
// Oscillator Switchover mode disabled
#define IESO_OFF             0xFFFF 


// Config Register: CONFIG2L
// Power-up Timer Enable bit
// PWRT disabled
#define PWRT_OFF             0xFFFF 
// PWRT enabled
#define PWRT_ON              0xFFFE 
// Brown-out Reset Enable bits
// Brown-out Reset enabled in hardware only (SBOREN is disabled)
#define BOREN_BOHW           0xFFFF 
// Brown-out Reset enabled in hardware only and disabled in Sleep mode (SBOREN is disabled)
#define BOREN_BOACTIVE       0xFFFD 
// Brown-out Reset enabled and controlled by software (SBOREN is enabled)
#define BOREN_SBORENCTRL     0xFFFB 
// Brown-out Reset disabled in hardware and software
#define BOREN_OFF            0xFFF9 
// Brown-out Reset Voltage bits
// VBOR set to 2.1V
#define BORV_3               0xFFFF 
// VBOR set to 2.8V
#define BORV_2               0xFFF7 
// VBOR set to 4.3V
#define BORV_1               0xFFEF 
// VBOR set to 4.6V
#define BORV_0               0xFFE7 


// 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:32768
#define WDTPS_32768          0xFFFF 
// 1:16384
#define WDTPS_16384          0xFDFF 
// 1:8192
#define WDTPS_8192           0xFBFF 
// 1:4096
#define WDTPS_4096           0xF9FF 
// 1:2048
#define WDTPS_2048           0xF7FF 
// 1:1024
#define WDTPS_1024           0xF5FF 
// 1:512
#define WDTPS_512            0xF3FF 
// 1:256
#define WDTPS_256            0xF1FF 
// 1:128
#define WDTPS_128            0xEFFF 
// 1:64
#define WDTPS_64             0xEDFF 
// 1:32
#define WDTPS_32             0xEBFF 
// 1:16
#define WDTPS_16             0xE9FF 
// 1:8
#define WDTPS_8              0xE7FF 
// 1:4
#define WDTPS_4              0xE5FF 
// 1:2
#define WDTPS_2              0xE3FF 
// 1:1
#define WDTPS_1              0xE1FF 


// Config Register: CONFIG3H
// PORTB A/D Enable bit
// PORTB<4:0> pins are configured as analog input channels on Reset
#define PBADEN_ON            0xFFFF 
// PORTB<4:0> pins are configured as digital I/O on Reset
#define PBADEN_OFF           0xFDFF 
// Low-Power Timer 1 Oscillator Enable bit
// Timer1 configured for low-power operation
#define LPT1OSC_ON           0xFBFF 
// Timer1 configured for higher power operation
#define LPT1OSC_OFF          0xFFFF 
// MCLR Pin Enable bit
// MCLR pin enabled; RE3 input pin disabled
#define MCLRE_ON             0xFFFF 
// RE3 input pin enabled; MCLR disabled
#define MCLRE_OFF            0x7FFF 


// Config Register: CONFIG4L
// Stack Full/Underflow Reset Enable bit
// Stack full/underflow will cause Reset
#define STVREN_ON            0xFFFF 
// Stack full/underflow will not cause Reset
#define STVREN_OFF           0xFFFE 
// Single-Supply ICSP Enable bit
// Single-Supply ICSP enabled
#define LVP_ON               0xFFFF 
// Single-Supply ICSP disabled
#define LVP_OFF              0xFFFB 
// Boot Block Size Select bits
// 4K words (8K bytes) Boot Block
#define BBSIZ_4096           0xFFDF 
// 2K words (4K bytes) Boot Block
#define BBSIZ_2048           0xFFEF 
// 1K words (2K bytes) Boot Block
#define BBSIZ_1024           0xFFFF 
// Extended Instruction Set Enable bit
// Instruction set extension and Indexed Addressing mode enabled
#define XINST_ON             0xFFBF 
// Instruction set extension and Indexed Addressing mode disabled (Legacy mode)
#define XINST_OFF            0xFFFF 
// 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 (000800-003FFFh) not code-protected
#define CP0_OFF              0xFFFF 
// Block 0 (000800-003FFFh) code-protected
#define CP0_ON               0xFFFE 
// Code Protection bit
// Block 1 (004000-007FFFh) not code-protected
#define CP1_OFF              0xFFFF 
// Block 1 (004000-007FFFh) code-protected
#define CP1_ON               0xFFFD 
// Code Protection bit
// Block 2 (008000-00BFFFh) not code-protected
#define CP2_OFF              0xFFFF 
// Block 2 (008000-00BFFFh) code-protected
#define CP2_ON               0xFFFB 
// Code Protection bit
// Block 3 (00C000-00FFFFh) not code-protected
#define CP3_OFF              0xFFFF 
// Block 3 (00C000-00FFFFh) code-protected
#define CP3_ON               0xFFF7 


// Config Register: CONFIG5H
// Boot Block Code Protection bit
// Boot block (000000-0007FFh) not code-protected
#define CPB_OFF              0xFFFF 
// Boot block (000000-0007FFh) 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 (000800-003FFFh) not write-protected
#define WRT0_OFF             0xFFFF 
// Block 0 (000800-003FFFh) write-protected
#define WRT0_ON              0xFFFE 
// Write Protection bit
// Block 1 (004000-007FFFh) not write-protected
#define WRT1_OFF             0xFFFF 
// Block 1 (004000-007FFFh) write-protected
#define WRT1_ON              0xFFFD 
// Write Protection bit
// Block 2 (008000-00BFFFh) not write-protected
#define WRT2_OFF             0xFFFF 
// Block 2 (008000-00BFFFh) write-protected
#define WRT2_ON              0xFFFB 
// Write Protection bit
// Block 3 (00C000-00FFFFh) not write-protected
#define WRT3_OFF             0xFFFF 
// Block 3 (00C000-00FFFFh) 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-0007FFh) not write-protected
#define WRTB_OFF             0xFFFF 
// Boot block (000000-0007FFh) 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 (000800-003FFFh) not protected from table reads executed in other blocks
#define EBTR0_OFF            0xFFFF 
// Block 0 (000800-003FFFh) protected from table reads executed in other blocks
#define EBTR0_ON             0xFFFE 
// Table Read Protection bit
// Block 1 (004000-007FFFh) not protected from table reads executed in other blocks
#define EBTR1_OFF            0xFFFF 
// Block 1 (004000-007FFFh) protected from table reads executed in other blocks
#define EBTR1_ON             0xFFFD 
// Table Read Protection bit
// Block 2 (008000-00BFFFh) not protected from table reads executed in other blocks
#define EBTR2_OFF            0xFFFF 
// Block 2 (008000-00BFFFh) protected from table reads executed in other blocks
#define EBTR2_ON             0xFFFB 
// Table Read Protection bit
// Block 3 (00C000-00FFFFh) not protected from table reads executed in other blocks
#define EBTR3_OFF            0xFFFF 
// Block 3 (00C000-00FFFFh) protected from table reads executed in other blocks
#define EBTR3_ON             0xFFF7 


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


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

// Register: RXF6SIDH
extern volatile unsigned char           RXF6SIDH            @ 0xD60;
// bit and bitfield definitions
//extern volatile bit SID3               @ ((unsigned)&RXF6SIDH*8)+0;
//extern volatile bit SID4               @ ((unsigned)&RXF6SIDH*8)+1;
//extern volatile bit SID5               @ ((unsigned)&RXF6SIDH*8)+2;
//extern volatile bit SID6               @ ((unsigned)&RXF6SIDH*8)+3;
//extern volatile bit SID7               @ ((unsigned)&RXF6SIDH*8)+4;
//extern volatile bit SID8               @ ((unsigned)&RXF6SIDH*8)+5;
//extern volatile bit SID9               @ ((unsigned)&RXF6SIDH*8)+6;
//extern volatile bit SID10              @ ((unsigned)&RXF6SIDH*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;
    };
} RXF6SIDHbits @ 0xD60;

// Register: RXF6SIDL
extern volatile unsigned char           RXF6SIDL            @ 0xD61;
// bit and bitfield definitions
//extern volatile bit EID16              @ ((unsigned)&RXF6SIDL*8)+0;
//extern volatile bit EID17              @ ((unsigned)&RXF6SIDL*8)+1;
//extern volatile bit EXIDEN             @ ((unsigned)&RXF6SIDL*8)+3;
//extern volatile bit SID0               @ ((unsigned)&RXF6SIDL*8)+5;
//extern volatile bit SID1               @ ((unsigned)&RXF6SIDL*8)+6;
//extern volatile bit SID2               @ ((unsigned)&RXF6SIDL*8)+7;
//extern volatile bit EXIDE              @ ((unsigned)&RXF6SIDL*8)+3;
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;
    };
    struct {
        volatile unsigned : 3;
        volatile unsigned EXIDE               : 1;
    };
} RXF6SIDLbits @ 0xD61;

// Register: RXF6EIDH
extern volatile unsigned char           RXF6EIDH            @ 0xD62;
// bit and bitfield definitions
//extern volatile bit EID8               @ ((unsigned)&RXF6EIDH*8)+0;
//extern volatile bit EID9               @ ((unsigned)&RXF6EIDH*8)+1;
//extern volatile bit EID10              @ ((unsigned)&RXF6EIDH*8)+2;
//extern volatile bit EID11              @ ((unsigned)&RXF6EIDH*8)+3;
//extern volatile bit EID12              @ ((unsigned)&RXF6EIDH*8)+4;
//extern volatile bit EID13              @ ((unsigned)&RXF6EIDH*8)+5;
//extern volatile bit EID14              @ ((unsigned)&RXF6EIDH*8)+6;
//extern volatile bit EID15              @ ((unsigned)&RXF6EIDH*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;
    };
} RXF6EIDHbits @ 0xD62;

// Register: RXF6EIDL
extern volatile unsigned char           RXF6EIDL            @ 0xD63;
// bit and bitfield definitions
//extern volatile bit EID0               @ ((unsigned)&RXF6EIDL*8)+0;
//extern volatile bit EID1               @ ((unsigned)&RXF6EIDL*8)+1;
//extern volatile bit EID2               @ ((unsigned)&RXF6EIDL*8)+2;
//extern volatile bit EID3               @ ((unsigned)&RXF6EIDL*8)+3;
//extern volatile bit EID4               @ ((unsigned)&RXF6EIDL*8)+4;
//extern volatile bit EID5               @ ((unsigned)&RXF6EIDL*8)+5;
//extern volatile bit EID6               @ ((unsigned)&RXF6EIDL*8)+6;
//extern volatile bit EID7               @ ((unsigned)&RXF6EIDL*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;
    };
} RXF6EIDLbits @ 0xD63;

// Register: RXF7SIDH
extern volatile unsigned char           RXF7SIDH            @ 0xD64;
// bit and bitfield definitions
//extern volatile bit SID3               @ ((unsigned)&RXF7SIDH*8)+0;
//extern volatile bit SID4               @ ((unsigned)&RXF7SIDH*8)+1;
//extern volatile bit SID5               @ ((unsigned)&RXF7SIDH*8)+2;
//extern volatile bit SID6               @ ((unsigned)&RXF7SIDH*8)+3;
//extern volatile bit SID7               @ ((unsigned)&RXF7SIDH*8)+4;
//extern volatile bit SID8               @ ((unsigned)&RXF7SIDH*8)+5;
//extern volatile bit SID9               @ ((unsigned)&RXF7SIDH*8)+6;
//extern volatile bit SID10              @ ((unsigned)&RXF7SIDH*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;
    };
} RXF7SIDHbits @ 0xD64;

// Register: RXF7SIDL
extern volatile unsigned char           RXF7SIDL            @ 0xD65;
// bit and bitfield definitions
//extern volatile bit EID16              @ ((unsigned)&RXF7SIDL*8)+0;
//extern volatile bit EID17              @ ((unsigned)&RXF7SIDL*8)+1;
//extern volatile bit EXIDEN             @ ((unsigned)&RXF7SIDL*8)+3;
//extern volatile bit SID0               @ ((unsigned)&RXF7SIDL*8)+5;
//extern volatile bit SID1               @ ((unsigned)&RXF7SIDL*8)+6;
//extern volatile bit SID2               @ ((unsigned)&RXF7SIDL*8)+7;
//extern volatile bit EXIDE              @ ((unsigned)&RXF7SIDL*8)+3;
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;
    };
    struct {
        volatile unsigned : 3;
        volatile unsigned EXIDE               : 1;
    };
} RXF7SIDLbits @ 0xD65;

// Register: RXF7EIDH
extern volatile unsigned char           RXF7EIDH            @ 0xD66;
// bit and bitfield definitions
//extern volatile bit EID8               @ ((unsigned)&RXF7EIDH*8)+0;
//extern volatile bit EID9               @ ((unsigned)&RXF7EIDH*8)+1;
//extern volatile bit EID10              @ ((unsigned)&RXF7EIDH*8)+2;
//extern volatile bit EID11              @ ((unsigned)&RXF7EIDH*8)+3;
//extern volatile bit EID12              @ ((unsigned)&RXF7EIDH*8)+4;
//extern volatile bit EID13              @ ((unsigned)&RXF7EIDH*8)+5;
//extern volatile bit EID14              @ ((unsigned)&RXF7EIDH*8)+6;
//extern volatile bit EID15              @ ((unsigned)&RXF7EIDH*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;
    };
} RXF7EIDHbits @ 0xD66;

// Register: RXF7EIDL
extern volatile unsigned char           RXF7EIDL            @ 0xD67;
// bit and bitfield definitions
//extern volatile bit EID0               @ ((unsigned)&RXF7EIDL*8)+0;
//extern volatile bit EID1               @ ((unsigned)&RXF7EIDL*8)+1;
//extern volatile bit EID2               @ ((unsigned)&RXF7EIDL*8)+2;
//extern volatile bit EID3               @ ((unsigned)&RXF7EIDL*8)+3;
//extern volatile bit EID4               @ ((unsigned)&RXF7EIDL*8)+4;
//extern volatile bit EID5               @ ((unsigned)&RXF7EIDL*8)+5;
//extern volatile bit EID6               @ ((unsigned)&RXF7EIDL*8)+6;
//extern volatile bit EID7               @ ((unsigned)&RXF7EIDL*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;
    };
} RXF7EIDLbits @ 0xD67;

// Register: RXF8SIDH
extern volatile unsigned char           RXF8SIDH            @ 0xD68;
// bit and bitfield definitions
//extern volatile bit SID3               @ ((unsigned)&RXF8SIDH*8)+0;
//extern volatile bit SID4               @ ((unsigned)&RXF8SIDH*8)+1;
//extern volatile bit SID5               @ ((unsigned)&RXF8SIDH*8)+2;
//extern volatile bit SID6               @ ((unsigned)&RXF8SIDH*8)+3;
//extern volatile bit SID7               @ ((unsigned)&RXF8SIDH*8)+4;
//extern volatile bit SID8               @ ((unsigned)&RXF8SIDH*8)+5;
//extern volatile bit SID9               @ ((unsigned)&RXF8SIDH*8)+6;
//extern volatile bit SID10              @ ((unsigned)&RXF8SIDH*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;
    };
} RXF8SIDHbits @ 0xD68;

// Register: RXF8SIDL
extern volatile unsigned char           RXF8SIDL            @ 0xD69;
// bit and bitfield definitions
//extern volatile bit EID16              @ ((unsigned)&RXF8SIDL*8)+0;
//extern volatile bit EID17              @ ((unsigned)&RXF8SIDL*8)+1;
//extern volatile bit EXIDEN             @ ((unsigned)&RXF8SIDL*8)+3;
//extern volatile bit SID0               @ ((unsigned)&RXF8SIDL*8)+5;
//extern volatile bit SID1               @ ((unsigned)&RXF8SIDL*8)+6;
//extern volatile bit SID2               @ ((unsigned)&RXF8SIDL*8)+7;
//extern volatile bit EXIDE              @ ((unsigned)&RXF8SIDL*8)+3;
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;
    };
    struct {
        volatile unsigned : 3;
        volatile unsigned EXIDE               : 1;
    };
} RXF8SIDLbits @ 0xD69;

// Register: RXF8EIDH
extern volatile unsigned char           RXF8EIDH            @ 0xD6A;
// bit and bitfield definitions
//extern volatile bit EID8               @ ((unsigned)&RXF8EIDH*8)+0;
//extern volatile bit EID9               @ ((unsigned)&RXF8EIDH*8)+1;
//extern volatile bit EID10              @ ((unsigned)&RXF8EIDH*8)+2;
//extern volatile bit EID11              @ ((unsigned)&RXF8EIDH*8)+3;
//extern volatile bit EID12              @ ((unsigned)&RXF8EIDH*8)+4;
//extern volatile bit EID13              @ ((unsigned)&RXF8EIDH*8)+5;
//extern volatile bit EID14              @ ((unsigned)&RXF8EIDH*8)+6;
//extern volatile bit EID15              @ ((unsigned)&RXF8EIDH*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;
    };
} RXF8EIDHbits @ 0xD6A;

// Register: RXF8EIDL
extern volatile unsigned char           RXF8EIDL            @ 0xD6B;
// bit and bitfield definitions
//extern volatile bit EID0               @ ((unsigned)&RXF8EIDL*8)+0;
//extern volatile bit EID1               @ ((unsigned)&RXF8EIDL*8)+1;
//extern volatile bit EID2               @ ((unsigned)&RXF8EIDL*8)+2;
//extern volatile bit EID3               @ ((unsigned)&RXF8EIDL*8)+3;
//extern volatile bit EID4               @ ((unsigned)&RXF8EIDL*8)+4;
//extern volatile bit EID5               @ ((unsigned)&RXF8EIDL*8)+5;
//extern volatile bit EID6               @ ((unsigned)&RXF8EIDL*8)+6;
//extern volatile bit EID7               @ ((unsigned)&RXF8EIDL*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;
    };
} RXF8EIDLbits @ 0xD6B;

// Register: RXF9SIDH
extern volatile unsigned char           RXF9SIDH            @ 0xD70;
// bit and bitfield definitions
//extern volatile bit SID3               @ ((unsigned)&RXF9SIDH*8)+0;
//extern volatile bit SID4               @ ((unsigned)&RXF9SIDH*8)+1;
//extern volatile bit SID5               @ ((unsigned)&RXF9SIDH*8)+2;
//extern volatile bit SID6               @ ((unsigned)&RXF9SIDH*8)+3;
//extern volatile bit SID7               @ ((unsigned)&RXF9SIDH*8)+4;
//extern volatile bit SID8               @ ((unsigned)&RXF9SIDH*8)+5;
//extern volatile bit SID9               @ ((unsigned)&RXF9SIDH*8)+6;
//extern volatile bit SID10              @ ((unsigned)&RXF9SIDH*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;
    };
} RXF9SIDHbits @ 0xD70;

// Register: RXF9SIDL
extern volatile unsigned char           RXF9SIDL            @ 0xD71;
// bit and bitfield definitions
//extern volatile bit EID16              @ ((unsigned)&RXF9SIDL*8)+0;
//extern volatile bit EID17              @ ((unsigned)&RXF9SIDL*8)+1;
//extern volatile bit EXIDEN             @ ((unsigned)&RXF9SIDL*8)+3;
//extern volatile bit SID0               @ ((unsigned)&RXF9SIDL*8)+5;
//extern volatile bit SID1               @ ((unsigned)&RXF9SIDL*8)+6;
//extern volatile bit SID2               @ ((unsigned)&RXF9SIDL*8)+7;
//extern volatile bit EXIDE              @ ((unsigned)&RXF9SIDL*8)+3;
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;
    };
    struct {
        volatile unsigned : 3;
        volatile unsigned EXIDE               : 1;
    };
} RXF9SIDLbits @ 0xD71;

// Register: RXF9EIDH
extern volatile unsigned char           RXF9EIDH            @ 0xD72;
// bit and bitfield definitions
//extern volatile bit EID8               @ ((unsigned)&RXF9EIDH*8)+0;
//extern volatile bit EID9               @ ((unsigned)&RXF9EIDH*8)+1;
//extern volatile bit EID10              @ ((unsigned)&RXF9EIDH*8)+2;
//extern volatile bit EID11              @ ((unsigned)&RXF9EIDH*8)+3;
//extern volatile bit EID12              @ ((unsigned)&RXF9EIDH*8)+4;
//extern volatile bit EID13              @ ((unsigned)&RXF9EIDH*8)+5;
//extern volatile bit EID14              @ ((unsigned)&RXF9EIDH*8)+6;
//extern volatile bit EID15              @ ((unsigned)&RXF9EIDH*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;
    };
} RXF9EIDHbits @ 0xD72;

// Register: RXF9EIDL
extern volatile unsigned char           RXF9EIDL            @ 0xD73;
// bit and bitfield definitions
//extern volatile bit EID0               @ ((unsigned)&RXF9EIDL*8)+0;
//extern volatile bit EID1               @ ((unsigned)&RXF9EIDL*8)+1;
//extern volatile bit EID2               @ ((unsigned)&RXF9EIDL*8)+2;
//extern volatile bit EID3               @ ((unsigned)&RXF9EIDL*8)+3;
//extern volatile bit EID4               @ ((unsigned)&RXF9EIDL*8)+4;
//extern volatile bit EID5               @ ((unsigned)&RXF9EIDL*8)+5;
//extern volatile bit EID6               @ ((unsigned)&RXF9EIDL*8)+6;
//extern volatile bit EID7               @ ((unsigned)&RXF9EIDL*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;
    };
} RXF9EIDLbits @ 0xD73;

// Register: RXF10SIDH
extern volatile unsigned char           RXF10SIDH           @ 0xD74;
// bit and bitfield definitions
//extern volatile bit SID3               @ ((unsigned)&RXF10SIDH*8)+0;
//extern volatile bit SID4               @ ((unsigned)&RXF10SIDH*8)+1;
//extern volatile bit SID5               @ ((unsigned)&RXF10SIDH*8)+2;
//extern volatile bit SID6               @ ((unsigned)&RXF10SIDH*8)+3;
//extern volatile bit SID7               @ ((unsigned)&RXF10SIDH*8)+4;
//extern volatile bit SID8               @ ((unsigned)&RXF10SIDH*8)+5;
//extern volatile bit SID9               @ ((unsigned)&RXF10SIDH*8)+6;
//extern volatile bit SID10              @ ((unsigned)&RXF10SIDH*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;
    };
} RXF10SIDHbits @ 0xD74;

// Register: RXF10SIDL
extern volatile unsigned char           RXF10SIDL           @ 0xD75;
// bit and bitfield definitions
//extern volatile bit EID16              @ ((unsigned)&RXF10SIDL*8)+0;
//extern volatile bit EID17              @ ((unsigned)&RXF10SIDL*8)+1;
//extern volatile bit EXIDEN             @ ((unsigned)&RXF10SIDL*8)+3;
//extern volatile bit SID0               @ ((unsigned)&RXF10SIDL*8)+5;
//extern volatile bit SID1               @ ((unsigned)&RXF10SIDL*8)+6;
//extern volatile bit SID2               @ ((unsigned)&RXF10SIDL*8)+7;
//extern volatile bit EXIDE              @ ((unsigned)&RXF10SIDL*8)+3;
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;
    };
    struct {
        volatile unsigned : 3;
        volatile unsigned EXIDE               : 1;
    };
} RXF10SIDLbits @ 0xD75;

// Register: RXF10EIDH
extern volatile unsigned char           RXF10EIDH           @ 0xD76;
// bit and bitfield definitions
//extern volatile bit EID8               @ ((unsigned)&RXF10EIDH*8)+0;
//extern volatile bit EID9               @ ((unsigned)&RXF10EIDH*8)+1;
//extern volatile bit EID10              @ ((unsigned)&RXF10EIDH*8)+2;
//extern volatile bit EID11              @ ((unsigned)&RXF10EIDH*8)+3;
//extern volatile bit EID12              @ ((unsigned)&RXF10EIDH*8)+4;
//extern volatile bit EID13              @ ((unsigned)&RXF10EIDH*8)+5;
//extern volatile bit EID14              @ ((unsigned)&RXF10EIDH*8)+6;
//extern volatile bit EID15              @ ((unsigned)&RXF10EIDH*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;
    };
} RXF10EIDHbits @ 0xD76;

// Register: RXF10EIDL
extern volatile unsigned char           RXF10EIDL           @ 0xD77;
// bit and bitfield definitions
//extern volatile bit EID0               @ ((unsigned)&RXF10EIDL*8)+0;
//extern volatile bit EID1               @ ((unsigned)&RXF10EIDL*8)+1;
//extern volatile bit EID2               @ ((unsigned)&RXF10EIDL*8)+2;
//extern volatile bit EID3               @ ((unsigned)&RXF10EIDL*8)+3;
//extern volatile bit EID4               @ ((unsigned)&RXF10EIDL*8)+4;
//extern volatile bit EID5               @ ((unsigned)&RXF10EIDL*8)+5;
//extern volatile bit EID6               @ ((unsigned)&RXF10EIDL*8)+6;
//extern volatile bit EID7               @ ((unsigned)&RXF10EIDL*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;
    };
} RXF10EIDLbits @ 0xD77;

// Register: RXF11SIDH
extern volatile unsigned char           RXF11SIDH           @ 0xD78;
// bit and bitfield definitions
//extern volatile bit SID3               @ ((unsigned)&RXF11SIDH*8)+0;
//extern volatile bit SID4               @ ((unsigned)&RXF11SIDH*8)+1;
//extern volatile bit SID5               @ ((unsigned)&RXF11SIDH*8)+2;
//extern volatile bit SID6               @ ((unsigned)&RXF11SIDH*8)+3;
//extern volatile bit SID7               @ ((unsigned)&RXF11SIDH*8)+4;
//extern volatile bit SID8               @ ((unsigned)&RXF11SIDH*8)+5;
//extern volatile bit SID9               @ ((unsigned)&RXF11SIDH*8)+6;
//extern volatile bit SID10              @ ((unsigned)&RXF11SIDH*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;
    };
} RXF11SIDHbits @ 0xD78;

// Register: RXF11SIDL
extern volatile unsigned char           RXF11SIDL           @ 0xD79;
// bit and bitfield definitions
//extern volatile bit EID16              @ ((unsigned)&RXF11SIDL*8)+0;
//extern volatile bit EID17              @ ((unsigned)&RXF11SIDL*8)+1;
//extern volatile bit EXIDEN             @ ((unsigned)&RXF11SIDL*8)+3;
//extern volatile bit SID0               @ ((unsigned)&RXF11SIDL*8)+5;
//extern volatile bit SID1               @ ((unsigned)&RXF11SIDL*8)+6;
//extern volatile bit SID2               @ ((unsigned)&RXF11SIDL*8)+7;
//extern volatile bit EXIDE              @ ((unsigned)&RXF11SIDL*8)+3;
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;
    };
    struct {
        volatile unsigned : 3;
        volatile unsigned EXIDE               : 1;
    };
} RXF11SIDLbits @ 0xD79;

// Register: RXF11EIDH
extern volatile unsigned char           RXF11EIDH           @ 0xD7A;
// bit and bitfield definitions
//extern volatile bit EID8               @ ((unsigned)&RXF11EIDH*8)+0;
//extern volatile bit EID9               @ ((unsigned)&RXF11EIDH*8)+1;
//extern volatile bit EID10              @ ((unsigned)&RXF11EIDH*8)+2;
//extern volatile bit EID11              @ ((unsigned)&RXF11EIDH*8)+3;
//extern volatile bit EID12              @ ((unsigned)&RXF11EIDH*8)+4;
//extern volatile bit EID13              @ ((unsigned)&RXF11EIDH*8)+5;
//extern volatile bit EID14              @ ((unsigned)&RXF11EIDH*8)+6;
//extern volatile bit EID15              @ ((unsigned)&RXF11EIDH*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;
    };
} RXF11EIDHbits @ 0xD7A;

// Register: RXF11EIDL
extern volatile unsigned char           RXF11EIDL           @ 0xD7B;
// bit and bitfield definitions
//extern volatile bit EID0               @ ((unsigned)&RXF11EIDL*8)+0;
//extern volatile bit EID1               @ ((unsigned)&RXF11EIDL*8)+1;
//extern volatile bit EID2               @ ((unsigned)&RXF11EIDL*8)+2;
//extern volatile bit EID3               @ ((unsigned)&RXF11EIDL*8)+3;
//extern volatile bit EID4               @ ((unsigned)&RXF11EIDL*8)+4;
//extern volatile bit EID5               @ ((unsigned)&RXF11EIDL*8)+5;
//extern volatile bit EID6               @ ((unsigned)&RXF11EIDL*8)+6;
//extern volatile bit EID7               @ ((unsigned)&RXF11EIDL*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;
    };
} RXF11EIDLbits @ 0xD7B;

// Register: RXF12SIDH
extern volatile unsigned char           RXF12SIDH           @ 0xD80;
// bit and bitfield definitions
//extern volatile bit SID3               @ ((unsigned)&RXF12SIDH*8)+0;
//extern volatile bit SID4               @ ((unsigned)&RXF12SIDH*8)+1;
//extern volatile bit SID5               @ ((unsigned)&RXF12SIDH*8)+2;
//extern volatile bit SID6               @ ((unsigned)&RXF12SIDH*8)+3;
//extern volatile bit SID7               @ ((unsigned)&RXF12SIDH*8)+4;
//extern volatile bit SID8               @ ((unsigned)&RXF12SIDH*8)+5;
//extern volatile bit SID9               @ ((unsigned)&RXF12SIDH*8)+6;
//extern volatile bit SID10              @ ((unsigned)&RXF12SIDH*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;
    };
} RXF12SIDHbits @ 0xD80;

// Register: RXF12SIDL
extern volatile unsigned char           RXF12SIDL           @ 0xD81;
// bit and bitfield definitions
//extern volatile bit EID16              @ ((unsigned)&RXF12SIDL*8)+0;
//extern volatile bit EID17              @ ((unsigned)&RXF12SIDL*8)+1;
//extern volatile bit EXIDEN             @ ((unsigned)&RXF12SIDL*8)+3;
//extern volatile bit SID0               @ ((unsigned)&RXF12SIDL*8)+5;
//extern volatile bit SID1               @ ((unsigned)&RXF12SIDL*8)+6;
//extern volatile bit SID2               @ ((unsigned)&RXF12SIDL*8)+7;
//extern volatile bit EXIDE              @ ((unsigned)&RXF12SIDL*8)+3;
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;
    };
    struct {
        volatile unsigned : 3;
        volatile unsigned EXIDE               : 1;
    };
} RXF12SIDLbits @ 0xD81;

// Register: RXF12EIDH
extern volatile unsigned char           RXF12EIDH           @ 0xD82;
// bit and bitfield definitions
//extern volatile bit EID8               @ ((unsigned)&RXF12EIDH*8)+0;
//extern volatile bit EID9               @ ((unsigned)&RXF12EIDH*8)+1;
//extern volatile bit EID10              @ ((unsigned)&RXF12EIDH*8)+2;
//extern volatile bit EID11              @ ((unsigned)&RXF12EIDH*8)+3;
//extern volatile bit EID12              @ ((unsigned)&RXF12EIDH*8)+4;
//extern volatile bit EID13              @ ((unsigned)&RXF12EIDH*8)+5;
//extern volatile bit EID14              @ ((unsigned)&RXF12EIDH*8)+6;
//extern volatile bit EID15              @ ((unsigned)&RXF12EIDH*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;
    };
} RXF12EIDHbits @ 0xD82;

// Register: RXF12EIDL
extern volatile unsigned char           RXF12EIDL           @ 0xD83;
// bit and bitfield definitions
//extern volatile bit EID0               @ ((unsigned)&RXF12EIDL*8)+0;
//extern volatile bit EID1               @ ((unsigned)&RXF12EIDL*8)+1;
//extern volatile bit EID2               @ ((unsigned)&RXF12EIDL*8)+2;
//extern volatile bit EID3               @ ((unsigned)&RXF12EIDL*8)+3;
//extern volatile bit EID4               @ ((unsigned)&RXF12EIDL*8)+4;
//extern volatile bit EID5               @ ((unsigned)&RXF12EIDL*8)+5;
//extern volatile bit EID6               @ ((unsigned)&RXF12EIDL*8)+6;
//extern volatile bit EID7               @ ((unsigned)&RXF12EIDL*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;
    };
} RXF12EIDLbits @ 0xD83;

// Register: RXF13SIDH
extern volatile unsigned char           RXF13SIDH           @ 0xD84;
// bit and bitfield definitions
//extern volatile bit SID3               @ ((unsigned)&RXF13SIDH*8)+0;
//extern volatile bit SID4               @ ((unsigned)&RXF13SIDH*8)+1;
//extern volatile bit SID5               @ ((unsigned)&RXF13SIDH*8)+2;
//extern volatile bit SID6               @ ((unsigned)&RXF13SIDH*8)+3;
//extern volatile bit SID7               @ ((unsigned)&RXF13SIDH*8)+4;
//extern volatile bit SID8               @ ((unsigned)&RXF13SIDH*8)+5;
//extern volatile bit SID9               @ ((unsigned)&RXF13SIDH*8)+6;
//extern volatile bit SID10              @ ((unsigned)&RXF13SIDH*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;
    };
} RXF13SIDHbits @ 0xD84;

// Register: RXF13SIDL
extern volatile unsigned char           RXF13SIDL           @ 0xD85;
// bit and bitfield definitions
//extern volatile bit EID16              @ ((unsigned)&RXF13SIDL*8)+0;
//extern volatile bit EID17              @ ((unsigned)&RXF13SIDL*8)+1;
//extern volatile bit EXIDEN             @ ((unsigned)&RXF13SIDL*8)+3;
//extern volatile bit SID0               @ ((unsigned)&RXF13SIDL*8)+5;
//extern volatile bit SID1               @ ((unsigned)&RXF13SIDL*8)+6;
//extern volatile bit SID2               @ ((unsigned)&RXF13SIDL*8)+7;
//extern volatile bit EXIDE              @ ((unsigned)&RXF13SIDL*8)+3;
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;
    };
    struct {
        volatile unsigned : 3;
        volatile unsigned EXIDE               : 1;
    };
} RXF13SIDLbits @ 0xD85;

// Register: RXF13EIDH
extern volatile unsigned char           RXF13EIDH           @ 0xD86;
// bit and bitfield definitions
//extern volatile bit EID8               @ ((unsigned)&RXF13EIDH*8)+0;
//extern volatile bit EID9               @ ((unsigned)&RXF13EIDH*8)+1;
//extern volatile bit EID10              @ ((unsigned)&RXF13EIDH*8)+2;
//extern volatile bit EID11              @ ((unsigned)&RXF13EIDH*8)+3;
//extern volatile bit EID12              @ ((unsigned)&RXF13EIDH*8)+4;
//extern volatile bit EID13              @ ((unsigned)&RXF13EIDH*8)+5;
//extern volatile bit EID14              @ ((unsigned)&RXF13EIDH*8)+6;
//extern volatile bit EID15              @ ((unsigned)&RXF13EIDH*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;
    };
} RXF13EIDHbits @ 0xD86;

// Register: RXF13EIDL
extern volatile unsigned char           RXF13EIDL           @ 0xD87;
// bit and bitfield definitions
//extern volatile bit EID0               @ ((unsigned)&RXF13EIDL*8)+0;
//extern volatile bit EID1               @ ((unsigned)&RXF13EIDL*8)+1;
//extern volatile bit EID2               @ ((unsigned)&RXF13EIDL*8)+2;
//extern volatile bit EID3               @ ((unsigned)&RXF13EIDL*8)+3;
//extern volatile bit EID4               @ ((unsigned)&RXF13EIDL*8)+4;
//extern volatile bit EID5               @ ((unsigned)&RXF13EIDL*8)+5;
//extern volatile bit EID6               @ ((unsigned)&RXF13EIDL*8)+6;
//extern volatile bit EID7               @ ((unsigned)&RXF13EIDL*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;
    };
} RXF13EIDLbits @ 0xD87;

// Register: RXF14SIDH
extern volatile unsigned char           RXF14SIDH           @ 0xD88;
// bit and bitfield definitions
//extern volatile bit SID3               @ ((unsigned)&RXF14SIDH*8)+0;
//extern volatile bit SID4               @ ((unsigned)&RXF14SIDH*8)+1;
//extern volatile bit SID5               @ ((unsigned)&RXF14SIDH*8)+2;
//extern volatile bit SID6               @ ((unsigned)&RXF14SIDH*8)+3;
//extern volatile bit SID7               @ ((unsigned)&RXF14SIDH*8)+4;
//extern volatile bit SID8               @ ((unsigned)&RXF14SIDH*8)+5;
//extern volatile bit SID9               @ ((unsigned)&RXF14SIDH*8)+6;
//extern volatile bit SID10              @ ((unsigned)&RXF14SIDH*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;
    };
} RXF14SIDHbits @ 0xD88;

// Register: RXF14SIDL
extern volatile unsigned char           RXF14SIDL           @ 0xD89;
// bit and bitfield definitions
//extern volatile bit EID16              @ ((unsigned)&RXF14SIDL*8)+0;
//extern volatile bit EID17              @ ((unsigned)&RXF14SIDL*8)+1;
//extern volatile bit EXIDEN             @ ((unsigned)&RXF14SIDL*8)+3;
//extern volatile bit SID0               @ ((unsigned)&RXF14SIDL*8)+5;
//extern volatile bit SID1               @ ((unsigned)&RXF14SIDL*8)+6;
//extern volatile bit SID2               @ ((unsigned)&RXF14SIDL*8)+7;
//extern volatile bit EXIDE              @ ((unsigned)&RXF14SIDL*8)+3;
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;
    };
    struct {
        volatile unsigned : 3;
        volatile unsigned EXIDE               : 1;
    };
} RXF14SIDLbits @ 0xD89;

// Register: RXF14EIDH
extern volatile unsigned char           RXF14EIDH           @ 0xD8A;
// bit and bitfield definitions
//extern volatile bit EID8               @ ((unsigned)&RXF14EIDH*8)+0;
//extern volatile bit EID9               @ ((unsigned)&RXF14EIDH*8)+1;
//extern volatile bit EID10              @ ((unsigned)&RXF14EIDH*8)+2;
//extern volatile bit EID11              @ ((unsigned)&RXF14EIDH*8)+3;
//extern volatile bit EID12              @ ((unsigned)&RXF14EIDH*8)+4;
//extern volatile bit EID13              @ ((unsigned)&RXF14EIDH*8)+5;
//extern volatile bit EID14              @ ((unsigned)&RXF14EIDH*8)+6;
//extern volatile bit EID15              @ ((unsigned)&RXF14EIDH*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;
    };
} RXF14EIDHbits @ 0xD8A;

// Register: RXF14EIDL
extern volatile unsigned char           RXF14EIDL           @ 0xD8B;
// bit and bitfield definitions
//extern volatile bit EID0               @ ((unsigned)&RXF14EIDL*8)+0;
//extern volatile bit EID1               @ ((unsigned)&RXF14EIDL*8)+1;
//extern volatile bit EID2               @ ((unsigned)&RXF14EIDL*8)+2;
//extern volatile bit EID3               @ ((unsigned)&RXF14EIDL*8)+3;
//extern volatile bit EID4               @ ((unsigned)&RXF14EIDL*8)+4;
//extern volatile bit EID5               @ ((unsigned)&RXF14EIDL*8)+5;
//extern volatile bit EID6               @ ((unsigned)&RXF14EIDL*8)+6;
//extern volatile bit EID7               @ ((unsigned)&RXF14EIDL*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;
    };
} RXF14EIDLbits @ 0xD8B;

// Register: RXF15SIDH
extern volatile unsigned char           RXF15SIDH           @ 0xD90;
// bit and bitfield definitions
//extern volatile bit SID3               @ ((unsigned)&RXF15SIDH*8)+0;
//extern volatile bit SID4               @ ((unsigned)&RXF15SIDH*8)+1;
//extern volatile bit SID5               @ ((unsigned)&RXF15SIDH*8)+2;
//extern volatile bit SID6               @ ((unsigned)&RXF15SIDH*8)+3;
//extern volatile bit SID7               @ ((unsigned)&RXF15SIDH*8)+4;
//extern volatile bit SID8               @ ((unsigned)&RXF15SIDH*8)+5;
//extern volatile bit SID9               @ ((unsigned)&RXF15SIDH*8)+6;
//extern volatile bit SID10              @ ((unsigned)&RXF15SIDH*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;
    };
} RXF15SIDHbits @ 0xD90;

// Register: RXF15SIDL
extern volatile unsigned char           RXF15SIDL           @ 0xD91;
// bit and bitfield definitions
//extern volatile bit EID16              @ ((unsigned)&RXF15SIDL*8)+0;
//extern volatile bit EID17              @ ((unsigned)&RXF15SIDL*8)+1;
//extern volatile bit EXIDEN             @ ((unsigned)&RXF15SIDL*8)+3;
//extern volatile bit SID0               @ ((unsigned)&RXF15SIDL*8)+5;
//extern volatile bit SID1               @ ((unsigned)&RXF15SIDL*8)+6;
//extern volatile bit SID2               @ ((unsigned)&RXF15SIDL*8)+7;
//extern volatile bit EXIDE              @ ((unsigned)&RXF15SIDL*8)+3;
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;
    };
    struct {
        volatile unsigned : 3;
        volatile unsigned EXIDE               : 1;
    };
} RXF15SIDLbits @ 0xD91;

// Register: RXF15EIDH
extern volatile unsigned char           RXF15EIDH           @ 0xD92;
// bit and bitfield definitions
//extern volatile bit EID8               @ ((unsigned)&RXF15EIDH*8)+0;
//extern volatile bit EID9               @ ((unsigned)&RXF15EIDH*8)+1;
//extern volatile bit EID10              @ ((unsigned)&RXF15EIDH*8)+2;
//extern volatile bit EID11              @ ((unsigned)&RXF15EIDH*8)+3;
//extern volatile bit EID12              @ ((unsigned)&RXF15EIDH*8)+4;
//extern volatile bit EID13              @ ((unsigned)&RXF15EIDH*8)+5;
//extern volatile bit EID14              @ ((unsigned)&RXF15EIDH*8)+6;
//extern volatile bit EID15              @ ((unsigned)&RXF15EIDH*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;
    };
} RXF15EIDHbits @ 0xD92;

// Register: RXF15EIDL
extern volatile unsigned char           RXF15EIDL           @ 0xD93;
// bit and bitfield definitions
//extern volatile bit EID0               @ ((unsigned)&RXF15EIDL*8)+0;
//extern volatile bit EID1               @ ((unsigned)&RXF15EIDL*8)+1;
//extern volatile bit EID2               @ ((unsigned)&RXF15EIDL*8)+2;
//extern volatile bit EID3               @ ((unsigned)&RXF15EIDL*8)+3;
//extern volatile bit EID4               @ ((unsigned)&RXF15EIDL*8)+4;
//extern volatile bit EID5               @ ((unsigned)&RXF15EIDL*8)+5;
//extern volatile bit EID6               @ ((unsigned)&RXF15EIDL*8)+6;
//extern volatile bit EID7               @ ((unsigned)&RXF15EIDL*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;
    };
} RXF15EIDLbits @ 0xD93;

// Register: RXFCON0
extern volatile unsigned char           RXFCON0             @ 0xDD4;
// bit and bitfield definitions
extern volatile bit RXF0EN              @ ((unsigned)&RXFCON0*8)+0;
extern volatile bit RXF1EN              @ ((unsigned)&RXFCON0*8)+1;
extern volatile bit RXF2EN              @ ((unsigned)&RXFCON0*8)+2;
extern volatile bit RXF3EN              @ ((unsigned)&RXFCON0*8)+3;
extern volatile bit RXF4EN              @ ((unsigned)&RXFCON0*8)+4;
extern volatile bit RXF5EN              @ ((unsigned)&RXFCON0*8)+5;
extern volatile bit RXF6EN              @ ((unsigned)&RXFCON0*8)+6;
extern volatile bit RXF7EN              @ ((unsigned)&RXFCON0*8)+7;
extern union {
    struct {
        volatile unsigned RXF0EN              : 1;
        volatile unsigned RXF1EN              : 1;
        volatile unsigned RXF2EN              : 1;
        volatile unsigned RXF3EN              : 1;
        volatile unsigned RXF4EN              : 1;
        volatile unsigned RXF5EN              : 1;
        volatile unsigned RXF6EN              : 1;
        volatile unsigned RXF7EN              : 1;
    };
} RXFCON0bits @ 0xDD4;

// Register: RXFCON1
extern volatile unsigned char           RXFCON1             @ 0xDD5;
// bit and bitfield definitions
extern volatile bit RXF8EN              @ ((unsigned)&RXFCON1*8)+0;
extern volatile bit RXF9EN              @ ((unsigned)&RXFCON1*8)+1;
extern volatile bit RXF10EN             @ ((unsigned)&RXFCON1*8)+2;
extern volatile bit RXF11EN             @ ((unsigned)&RXFCON1*8)+3;
extern volatile bit RXF12EN             @ ((unsigned)&RXFCON1*8)+4;
extern volatile bit RXF13EN             @ ((unsigned)&RXFCON1*8)+5;
extern volatile bit RXF14EN             @ ((unsigned)&RXFCON1*8)+6;
extern volatile bit RXF15EN             @ ((unsigned)&RXFCON1*8)+7;
extern union {
    struct {
        volatile unsigned RXF8EN              : 1;
        volatile unsigned RXF9EN              : 1;
        volatile unsigned RXF10EN             : 1;
        volatile unsigned RXF11EN             : 1;
        volatile unsigned RXF12EN             : 1;
        volatile unsigned RXF13EN             : 1;
        volatile unsigned RXF14EN             : 1;
        volatile unsigned RXF15EN             : 1;
    };
} RXFCON1bits @ 0xDD5;

// Register: SDFLC
extern volatile unsigned char           SDFLC               @ 0xDD8;
// bit and bitfield definitions
extern volatile bit FLC0                @ ((unsigned)&SDFLC*8)+0;
extern volatile bit FLC1                @ ((unsigned)&SDFLC*8)+1;
extern volatile bit FLC2                @ ((unsigned)&SDFLC*8)+2;
extern volatile bit FLC3                @ ((unsigned)&SDFLC*8)+3;
extern volatile bit FLC4                @ ((unsigned)&SDFLC*8)+4;
extern volatile bit DFLC0               @ ((unsigned)&SDFLC*8)+0;
extern volatile bit DFLC1               @ ((unsigned)&SDFLC*8)+1;
extern volatile bit DFLC2               @ ((unsigned)&SDFLC*8)+2;
extern volatile bit DFLC3               @ ((unsigned)&SDFLC*8)+3;
extern volatile bit DFLC4               @ ((unsigned)&SDFLC*8)+4;
extern union {
    struct {
        volatile unsigned FLC0                : 1;
        volatile unsigned FLC1                : 1;
        volatile unsigned FLC2                : 1;
        volatile unsigned FLC3                : 1;
        volatile unsigned FLC4                : 1;
    };
    struct {
        volatile unsigned DFLC0               : 1;
        volatile unsigned DFLC1               : 1;
        volatile unsigned DFLC2               : 1;
        volatile unsigned DFLC3               : 1;
        volatile unsigned DFLC4               : 1;
    };
} SDFLCbits @ 0xDD8;

// Register: RXFBCON0
extern volatile unsigned char           RXFBCON0            @ 0xDE0;
// bit and bitfield definitions
extern volatile bit F0BP_0              @ ((unsigned)&RXFBCON0*8)+0;
extern volatile bit F0BP_1              @ ((unsigned)&RXFBCON0*8)+1;
extern volatile bit F0BP_2              @ ((unsigned)&RXFBCON0*8)+2;
extern volatile bit F0BP_3              @ ((unsigned)&RXFBCON0*8)+3;
extern volatile bit F1BP_0              @ ((unsigned)&RXFBCON0*8)+4;
extern volatile bit F1BP_1              @ ((unsigned)&RXFBCON0*8)+5;
extern volatile bit F1BP_2              @ ((unsigned)&RXFBCON0*8)+6;
extern volatile bit F1BP_3              @ ((unsigned)&RXFBCON0*8)+7;
extern union {
    struct {
        volatile unsigned F0BP_0              : 1;
        volatile unsigned F0BP_1              : 1;
        volatile unsigned F0BP_2              : 1;
        volatile unsigned F0BP_3              : 1;
        volatile unsigned F1BP_0              : 1;
        volatile unsigned F1BP_1              : 1;
        volatile unsigned F1BP_2              : 1;
        volatile unsigned F1BP_3              : 1;
    };
} RXFBCON0bits @ 0xDE0;

// Register: RXFBCON1
extern volatile unsigned char           RXFBCON1            @ 0xDE1;
// bit and bitfield definitions
extern volatile bit F2BP_0              @ ((unsigned)&RXFBCON1*8)+0;
extern volatile bit F2BP_1              @ ((unsigned)&RXFBCON1*8)+1;
extern volatile bit F2BP_2              @ ((unsigned)&RXFBCON1*8)+2;
extern volatile bit F2BP_3              @ ((unsigned)&RXFBCON1*8)+3;
extern volatile bit F3BP_0              @ ((unsigned)&RXFBCON1*8)+4;
extern volatile bit F3BP_1              @ ((unsigned)&RXFBCON1*8)+5;
extern volatile bit F3BP_2              @ ((unsigned)&RXFBCON1*8)+6;
extern volatile bit F3BP_3              @ ((unsigned)&RXFBCON1*8)+7;
extern union {
    struct {
        volatile unsigned F2BP_0              : 1;
        volatile unsigned F2BP_1              : 1;
        volatile unsigned F2BP_2              : 1;
        volatile unsigned F2BP_3              : 1;
        volatile unsigned F3BP_0              : 1;
        volatile unsigned F3BP_1              : 1;
        volatile unsigned F3BP_2              : 1;
        volatile unsigned F3BP_3              : 1;
    };
} RXFBCON1bits @ 0xDE1;

// Register: RXFBCON2
extern volatile unsigned char           RXFBCON2            @ 0xDE2;
// bit and bitfield definitions
extern volatile bit F4BP_0              @ ((unsigned)&RXFBCON2*8)+0;
extern volatile bit F4BP_1              @ ((unsigned)&RXFBCON2*8)+1;
extern volatile bit F4BP_2              @ ((unsigned)&RXFBCON2*8)+2;
extern volatile bit F4BP_3              @ ((unsigned)&RXFBCON2*8)+3;
extern volatile bit F5BP_0              @ ((unsigned)&RXFBCON2*8)+4;
extern volatile bit F5BP_1              @ ((unsigned)&RXFBCON2*8)+5;
extern volatile bit F5BP_2              @ ((unsigned)&RXFBCON2*8)+6;
extern volatile bit F5BP_3              @ ((unsigned)&RXFBCON2*8)+7;
extern union {
    struct {
        volatile unsigned F4BP_0              : 1;
        volatile unsigned F4BP_1              : 1;
        volatile unsigned F4BP_2              : 1;
        volatile unsigned F4BP_3              : 1;
        volatile unsigned F5BP_0              : 1;
        volatile unsigned F5BP_1              : 1;
        volatile unsigned F5BP_2              : 1;
        volatile unsigned F5BP_3              : 1;
    };
} RXFBCON2bits @ 0xDE2;

// Register: RXFBCON3
extern volatile unsigned char           RXFBCON3            @ 0xDE3;
// bit and bitfield definitions
extern volatile bit F6BP_0              @ ((unsigned)&RXFBCON3*8)+0;
extern volatile bit F6BP_1              @ ((unsigned)&RXFBCON3*8)+1;
extern volatile bit F6BP_2              @ ((unsigned)&RXFBCON3*8)+2;
extern volatile bit F6BP_3              @ ((unsigned)&RXFBCON3*8)+3;
extern volatile bit F7BP_0              @ ((unsigned)&RXFBCON3*8)+4;
extern volatile bit F7BP_1              @ ((unsigned)&RXFBCON3*8)+5;
extern volatile bit F7BP_2              @ ((unsigned)&RXFBCON3*8)+6;
extern volatile bit F7BP_3              @ ((unsigned)&RXFBCON3*8)+7;
extern union {
    struct {
        volatile unsigned F6BP_0              : 1;
        volatile unsigned F6BP_1              : 1;
        volatile unsigned F6BP_2              : 1;
        volatile unsigned F6BP_3              : 1;
        volatile unsigned F7BP_0              : 1;
        volatile unsigned F7BP_1              : 1;
        volatile unsigned F7BP_2              : 1;
        volatile unsigned F7BP_3              : 1;
    };
} RXFBCON3bits @ 0xDE3;

// Register: RXFBCON4
extern volatile unsigned char           RXFBCON4            @ 0xDE4;
// bit and bitfield definitions
extern volatile bit F8BP_0              @ ((unsigned)&RXFBCON4*8)+0;
extern volatile bit F8BP_1              @ ((unsigned)&RXFBCON4*8)+1;
extern volatile bit F8BP_2              @ ((unsigned)&RXFBCON4*8)+2;
extern volatile bit F8BP_3              @ ((unsigned)&RXFBCON4*8)+3;
extern volatile bit F9BP_0              @ ((unsigned)&RXFBCON4*8)+4;
extern volatile bit F9BP_1              @ ((unsigned)&RXFBCON4*8)+5;
extern volatile bit F9BP_2              @ ((unsigned)&RXFBCON4*8)+6;
extern volatile bit F9BP_3              @ ((unsigned)&RXFBCON4*8)+7;
extern union {
    struct {
        volatile unsigned F8BP_0              : 1;
        volatile unsigned F8BP_1              : 1;
        volatile unsigned F8BP_2              : 1;
        volatile unsigned F8BP_3              : 1;
        volatile unsigned F9BP_0              : 1;
        volatile unsigned F9BP_1              : 1;
        volatile unsigned F9BP_2              : 1;
        volatile unsigned F9BP_3              : 1;
    };
} RXFBCON4bits @ 0xDE4;

// Register: RXFBCON5
extern volatile unsigned char           RXFBCON5            @ 0xDE5;
// bit and bitfield definitions
extern volatile bit F10BP_0             @ ((unsigned)&RXFBCON5*8)+0;
extern volatile bit F10BP_1             @ ((unsigned)&RXFBCON5*8)+1;
extern volatile bit F10BP_2             @ ((unsigned)&RXFBCON5*8)+2;
extern volatile bit F10BP_3             @ ((unsigned)&RXFBCON5*8)+3;
extern volatile bit F11BP_0             @ ((unsigned)&RXFBCON5*8)+4;
extern volatile bit F11BP_1             @ ((unsigned)&RXFBCON5*8)+5;
extern volatile bit F11BP_2             @ ((unsigned)&RXFBCON5*8)+6;
extern volatile bit F11BP_3             @ ((unsigned)&RXFBCON5*8)+7;
extern union {
    struct {
        volatile unsigned F10BP_0             : 1;
        volatile unsigned F10BP_1             : 1;
        volatile unsigned F10BP_2             : 1;
        volatile unsigned F10BP_3             : 1;
        volatile unsigned F11BP_0             : 1;
        volatile unsigned F11BP_1             : 1;
        volatile unsigned F11BP_2             : 1;
        volatile unsigned F11BP_3             : 1;
    };
} RXFBCON5bits @ 0xDE5;

// Register: RXFBCON6
extern volatile unsigned char           RXFBCON6            @ 0xDE6;
// bit and bitfield definitions
extern volatile bit F12BP_0             @ ((unsigned)&RXFBCON6*8)+0;
extern volatile bit F12BP_1             @ ((unsigned)&RXFBCON6*8)+1;
extern volatile bit F12BP_2             @ ((unsigned)&RXFBCON6*8)+2;
extern volatile bit F12BP_3             @ ((unsigned)&RXFBCON6*8)+3;
extern volatile bit F13BP_0             @ ((unsigned)&RXFBCON6*8)+4;
extern volatile bit F13BP_1             @ ((unsigned)&RXFBCON6*8)+5;
extern volatile bit F13BP_2             @ ((unsigned)&RXFBCON6*8)+6;
extern volatile bit F13BP_3             @ ((unsigned)&RXFBCON6*8)+7;
extern union {
    struct {
        volatile unsigned F12BP_0             : 1;
        volatile unsigned F12BP_1             : 1;
        volatile unsigned F12BP_2             : 1;
        volatile unsigned F12BP_3             : 1;
        volatile unsigned F13BP_0             : 1;
        volatile unsigned F13BP_1             : 1;
        volatile unsigned F13BP_2             : 1;
        volatile unsigned F13BP_3             : 1;
    };
} RXFBCON6bits @ 0xDE6;

// Register: RXFBCON7
extern volatile unsigned char           RXFBCON7            @ 0xDE7;
// bit and bitfield definitions
extern volatile bit F14BP_0             @ ((unsigned)&RXFBCON7*8)+0;
extern volatile bit F14BP_1             @ ((unsigned)&RXFBCON7*8)+1;
extern volatile bit F14BP_2             @ ((unsigned)&RXFBCON7*8)+2;
extern volatile bit F14BP_3             @ ((unsigned)&RXFBCON7*8)+3;
extern volatile bit F15BP_0             @ ((unsigned)&RXFBCON7*8)+4;
extern volatile bit F15BP_1             @ ((unsigned)&RXFBCON7*8)+5;
extern volatile bit F15BP_2             @ ((unsigned)&RXFBCON7*8)+6;
extern volatile bit F15BP_3             @ ((unsigned)&RXFBCON7*8)+7;
extern union {
    struct {
        volatile unsigned F14BP_0             : 1;
        volatile unsigned F14BP_1             : 1;
        volatile unsigned F14BP_2             : 1;
        volatile unsigned F14BP_3             : 1;
        volatile unsigned F15BP_0             : 1;
        volatile unsigned F15BP_1             : 1;
        volatile unsigned F15BP_2             : 1;
        volatile unsigned F15BP_3             : 1;
    };
} RXFBCON7bits @ 0xDE7;

// Register: MSEL0
extern volatile unsigned char           MSEL0               @ 0xDF0;
// bit and bitfield definitions
extern volatile bit FIL0_0              @ ((unsigned)&MSEL0*8)+0;
extern volatile bit FIL0_1              @ ((unsigned)&MSEL0*8)+1;
extern volatile bit FIL1_0              @ ((unsigned)&MSEL0*8)+2;
extern volatile bit FIL1_1              @ ((unsigned)&MSEL0*8)+3;
extern volatile bit FIL2_0              @ ((unsigned)&MSEL0*8)+4;
extern volatile bit FIL2_1              @ ((unsigned)&MSEL0*8)+5;
extern volatile bit FIL3_0              @ ((unsigned)&MSEL0*8)+6;
extern volatile bit FIL3_1              @ ((unsigned)&MSEL0*8)+7;
extern union {
    struct {
        volatile unsigned FIL0_0              : 1;
        volatile unsigned FIL0_1              : 1;
        volatile unsigned FIL1_0              : 1;
        volatile unsigned FIL1_1              : 1;
        volatile unsigned FIL2_0              : 1;
        volatile unsigned FIL2_1              : 1;
        volatile unsigned FIL3_0              : 1;
        volatile unsigned FIL3_1              : 1;
    };
} MSEL0bits @ 0xDF0;

// Register: MSEL1
extern volatile unsigned char           MSEL1               @ 0xDF1;
// bit and bitfield definitions
extern volatile bit FIL4_0              @ ((unsigned)&MSEL1*8)+0;
extern volatile bit FIL4_1              @ ((unsigned)&MSEL1*8)+1;
extern volatile bit FIL5_0              @ ((unsigned)&MSEL1*8)+2;
extern volatile bit FIL5_1              @ ((unsigned)&MSEL1*8)+3;
extern volatile bit FIL6_0              @ ((unsigned)&MSEL1*8)+4;
extern volatile bit FIL6_1              @ ((unsigned)&MSEL1*8)+5;
extern volatile bit FIL7_0              @ ((unsigned)&MSEL1*8)+6;
extern volatile bit FIL7_1              @ ((unsigned)&MSEL1*8)+7;
extern union {
    struct {
        volatile unsigned FIL4_0              : 1;
        volatile unsigned FIL4_1              : 1;
        volatile unsigned FIL5_0              : 1;
        volatile unsigned FIL5_1              : 1;
        volatile unsigned FIL6_0              : 1;
        volatile unsigned FIL6_1              : 1;
        volatile unsigned FIL7_0              : 1;
        volatile unsigned FIL7_1              : 1;
    };
} MSEL1bits @ 0xDF1;

// Register: MSEL2
extern volatile unsigned char           MSEL2               @ 0xDF2;
// bit and bitfield definitions
extern volatile bit FIL8_0              @ ((unsigned)&MSEL2*8)+0;
extern volatile bit FIL8_1              @ ((unsigned)&MSEL2*8)+1;
extern volatile bit FIL9_0              @ ((unsigned)&MSEL2*8)+2;
extern volatile bit FIL9_1              @ ((unsigned)&MSEL2*8)+3;
extern volatile bit FIL10_0             @ ((unsigned)&MSEL2*8)+4;
extern volatile bit FIL10_1             @ ((unsigned)&MSEL2*8)+5;
extern volatile bit FIL11_0             @ ((unsigned)&MSEL2*8)+6;
extern volatile bit FIL11_1             @ ((unsigned)&MSEL2*8)+7;
extern union {
    struct {
        volatile unsigned FIL8_0              : 1;
        volatile unsigned FIL8_1              : 1;
        volatile unsigned FIL9_0              : 1;
        volatile unsigned FIL9_1              : 1;
        volatile unsigned FIL10_0             : 1;
        volatile unsigned FIL10_1             : 1;
        volatile unsigned FIL11_0             : 1;
        volatile unsigned FIL11_1             : 1;
    };
} MSEL2bits @ 0xDF2;

// Register: MSEL3
extern volatile unsigned char           MSEL3               @ 0xDF3;
// bit and bitfield definitions
extern volatile bit FIL12_0             @ ((unsigned)&MSEL3*8)+0;
extern volatile bit FIL12_1             @ ((unsigned)&MSEL3*8)+1;
extern volatile bit FIL13_0             @ ((unsigned)&MSEL3*8)+2;
extern volatile bit FIL13_1             @ ((unsigned)&MSEL3*8)+3;
extern volatile bit FIL14_0             @ ((unsigned)&MSEL3*8)+4;
extern volatile bit FIL14_1             @ ((unsigned)&MSEL3*8)+5;
extern volatile bit FIL15_0             @ ((unsigned)&MSEL3*8)+6;
extern volatile bit FIL15_1             @ ((unsigned)&MSEL3*8)+7;
extern union {
    struct {
        volatile unsigned FIL12_0             : 1;
        volatile unsigned FIL12_1             : 1;
        volatile unsigned FIL13_0             : 1;
        volatile unsigned FIL13_1             : 1;
        volatile unsigned FIL14_0             : 1;
        volatile unsigned FIL14_1             : 1;
        volatile unsigned FIL15_0             : 1;
        volatile unsigned FIL15_1             : 1;
    };
} MSEL3bits @ 0xDF3;

// Register: BSEL0
extern volatile unsigned char           BSEL0               @ 0xDF8;
// bit and bitfield definitions
extern volatile bit B0TXEN              @ ((unsigned)&BSEL0*8)+2;
extern volatile bit B1TXEN              @ ((unsigned)&BSEL0*8)+3;
extern volatile bit B2TXEN              @ ((unsigned)&BSEL0*8)+4;
extern volatile bit B3TXEN              @ ((unsigned)&BSEL0*8)+5;
extern volatile bit B4TXEN              @ ((unsigned)&BSEL0*8)+6;
extern volatile bit B5TXEN              @ ((unsigned)&BSEL0*8)+7;
extern union {
    struct {
        volatile unsigned                     : 2;
        volatile unsigned B0TXEN              : 1;
        volatile unsigned B1TXEN              : 1;
        volatile unsigned B2TXEN              : 1;
        volatile unsigned B3TXEN              : 1;
        volatile unsigned B4TXEN              : 1;
        volatile unsigned B5TXEN              : 1;
    };
} BSEL0bits @ 0xDF8;

// Register: BIE0
extern volatile unsigned char           BIE0                @ 0xDFA;
// bit and bitfield definitions
//extern volatile bit RXB0IE             @ ((unsigned)&BIE0*8)+0;
//extern volatile bit RXB1IE             @ ((unsigned)&BIE0*8)+1;
extern volatile bit B0IE                @ ((unsigned)&BIE0*8)+2;
extern volatile bit B1IE                @ ((unsigned)&BIE0*8)+3;
extern volatile bit B2IE                @ ((unsigned)&BIE0*8)+4;
extern volatile bit B3IE                @ ((unsigned)&BIE0*8)+5;
extern volatile bit B4IE                @ ((unsigned)&BIE0*8)+6;
extern volatile bit B5IE                @ ((unsigned)&BIE0*8)+7;
extern union {
    struct {
        volatile unsigned RXB0IE              : 1;
        volatile unsigned RXB1IE              : 1;
        volatile unsigned B0IE                : 1;
        volatile unsigned B1IE                : 1;
        volatile unsigned B2IE                : 1;
        volatile unsigned B3IE                : 1;
        volatile unsigned B4IE                : 1;
        volatile unsigned B5IE                : 1;
    };
} BIE0bits @ 0xDFA;

// Register: TXBIE
extern volatile unsigned char           TXBIE               @ 0xDFC;
// bit and bitfield definitions
//extern volatile bit TXB0IE             @ ((unsigned)&TXBIE*8)+2;
//extern volatile bit TXB1IE             @ ((unsigned)&TXBIE*8)+3;
//extern volatile bit TXB2IE             @ ((unsigned)&TXBIE*8)+4;
extern union {
    struct {
        volatile unsigned                     : 2;
        volatile unsigned TXB0IE              : 1;
        volatile unsigned TXB1IE              : 1;
        volatile unsigned TXB2IE              : 1;
    };
} TXBIEbits @ 0xDFC;

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

// Register: B0CON
extern volatile unsigned char           B0CON               @ 0xE20;
// bit and bitfield definitions
//extern volatile bit FILHIT0_TXPRI0     @ ((unsigned)&B0CON*8)+0;
//extern volatile bit FILHIT1_TXPRI1     @ ((unsigned)&B0CON*8)+1;
//extern volatile bit FILHIT2_RTREN      @ ((unsigned)&B0CON*8)+2;
//extern volatile bit FILHIT3_TXREQ      @ ((unsigned)&B0CON*8)+3;
//extern volatile bit FILHIT4_TXERR      @ ((unsigned)&B0CON*8)+4;
//extern volatile bit RXRTRRO_TXLARB     @ ((unsigned)&B0CON*8)+5;
//extern volatile bit RXM1_TXABT         @ ((unsigned)&B0CON*8)+6;
//extern volatile bit RXFUL_TXBIF        @ ((unsigned)&B0CON*8)+7;
//extern volatile bit FILHIT0            @ ((unsigned)&B0CON*8)+0;
//extern volatile bit FILHIT1            @ ((unsigned)&B0CON*8)+1;
//extern volatile bit FILHIT2            @ ((unsigned)&B0CON*8)+2;
//extern volatile bit FILHIT3            @ ((unsigned)&B0CON*8)+3;
//extern volatile bit FILHIT4            @ ((unsigned)&B0CON*8)+4;
//extern volatile bit RTRRO              @ ((unsigned)&B0CON*8)+5;
//extern volatile bit RXM1               @ ((unsigned)&B0CON*8)+6;
//extern volatile bit RXFUL              @ ((unsigned)&B0CON*8)+7;
//extern volatile bit TXPRI0             @ ((unsigned)&B0CON*8)+0;
//extern volatile bit TXPRI1             @ ((unsigned)&B0CON*8)+1;
//extern volatile bit RTREN              @ ((unsigned)&B0CON*8)+2;
//extern volatile bit TXREQ              @ ((unsigned)&B0CON*8)+3;
//extern volatile bit TXERR              @ ((unsigned)&B0CON*8)+4;
//extern volatile bit TXLARB             @ ((unsigned)&B0CON*8)+5;
//extern volatile bit TXABT              @ ((unsigned)&B0CON*8)+6;
//extern volatile bit TXBIF              @ ((unsigned)&B0CON*8)+7;
//extern volatile bit RXRTRRO            @ ((unsigned)&B0CON*8)+5;
extern union {
    struct {
        volatile unsigned FILHIT0_TXPRI0      : 1;
        volatile unsigned FILHIT1_TXPRI1      : 1;
        volatile unsigned FILHIT2_RTREN       : 1;
        volatile unsigned FILHIT3_TXREQ       : 1;
        volatile unsigned FILHIT4_TXERR       : 1;
        volatile unsigned RXRTRRO_TXLARB      : 1;
        volatile unsigned RXM1_TXABT          : 1;
        volatile unsigned RXFUL_TXBIF         : 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 FILHIT0             : 1;
        volatile unsigned FILHIT1             : 1;
        volatile unsigned FILHIT2             : 1;
        volatile unsigned FILHIT3             : 1;
        volatile unsigned FILHIT4             : 1;
        volatile unsigned RTRRO               : 1;
        volatile unsigned RXM1                : 1;
        volatile unsigned RXFUL               : 1;
    };
    struct {
        volatile unsigned TXPRI0              : 1;
        volatile unsigned TXPRI1              : 1;
        volatile unsigned RTREN               : 1;
        volatile unsigned TXREQ               : 1;
        volatile unsigned TXERR               : 1;
        volatile unsigned TXLARB              : 1;
        volatile unsigned TXABT               : 1;
        volatile unsigned TXBIF               : 1;
    };
    struct {
        volatile unsigned                     : 5;
        volatile unsigned RXRTRRO             : 1;
    };
} B0CONbits @ 0xE20;

// Register: B0SIDH
extern volatile unsigned char           B0SIDH              @ 0xE21;
// bit and bitfield definitions
//extern volatile bit SID3               @ ((unsigned)&B0SIDH*8)+0;
//extern volatile bit SID4               @ ((unsigned)&B0SIDH*8)+1;
//extern volatile bit SID5               @ ((unsigned)&B0SIDH*8)+2;
//extern volatile bit SID6               @ ((unsigned)&B0SIDH*8)+3;
//extern volatile bit SID7               @ ((unsigned)&B0SIDH*8)+4;
//extern volatile bit SID8               @ ((unsigned)&B0SIDH*8)+5;
//extern volatile bit SID9               @ ((unsigned)&B0SIDH*8)+6;
//extern volatile bit SID10              @ ((unsigned)&B0SIDH*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;
    };
} B0SIDHbits @ 0xE21;

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

// Register: B0EIDH
extern volatile unsigned char           B0EIDH              @ 0xE23;
// bit and bitfield definitions
//extern volatile bit EID8               @ ((unsigned)&B0EIDH*8)+0;
//extern volatile bit EID9               @ ((unsigned)&B0EIDH*8)+1;
//extern volatile bit EID10              @ ((unsigned)&B0EIDH*8)+2;
//extern volatile bit EID11              @ ((unsigned)&B0EIDH*8)+3;
//extern volatile bit EID12              @ ((unsigned)&B0EIDH*8)+4;
//extern volatile bit EID13              @ ((unsigned)&B0EIDH*8)+5;
//extern volatile bit EID14              @ ((unsigned)&B0EIDH*8)+6;
//extern volatile bit EID15              @ ((unsigned)&B0EIDH*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;
    };
} B0EIDHbits @ 0xE23;

// Register: B0EIDL
extern volatile unsigned char           B0EIDL              @ 0xE24;
// bit and bitfield definitions
//extern volatile bit EID0               @ ((unsigned)&B0EIDL*8)+0;
//extern volatile bit EID1               @ ((unsigned)&B0EIDL*8)+1;
//extern volatile bit EID2               @ ((unsigned)&B0EIDL*8)+2;
//extern volatile bit EID3               @ ((unsigned)&B0EIDL*8)+3;
//extern volatile bit EID4               @ ((unsigned)&B0EIDL*8)+4;
//extern volatile bit EID5               @ ((unsigned)&B0EIDL*8)+5;
//extern volatile bit EID6               @ ((unsigned)&B0EIDL*8)+6;
//extern volatile bit EID7               @ ((unsigned)&B0EIDL*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;
    };
} B0EIDLbits @ 0xE24;

// Register: B0DLC
extern volatile unsigned char           B0DLC               @ 0xE25;
// bit and bitfield definitions
//extern volatile bit DLC0               @ ((unsigned)&B0DLC*8)+0;
//extern volatile bit DLC1               @ ((unsigned)&B0DLC*8)+1;
//extern volatile bit DLC2               @ ((unsigned)&B0DLC*8)+2;
//extern volatile bit DLC3               @ ((unsigned)&B0DLC*8)+3;
//extern volatile bit RB0                @ ((unsigned)&B0DLC*8)+4;
//extern volatile bit RB1                @ ((unsigned)&B0DLC*8)+5;
//extern volatile bit RXRTR_TXRTR        @ ((unsigned)&B0DLC*8)+6;
//extern volatile bit RESRB0             @ ((unsigned)&B0DLC*8)+4;
//extern volatile bit RESRB1             @ ((unsigned)&B0DLC*8)+5;
//extern volatile bit TXRTR              @ ((unsigned)&B0DLC*8)+6;
//extern volatile bit RXRTR              @ ((unsigned)&B0DLC*8)+6;
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_TXRTR         : 1;
    };
    struct {
        volatile unsigned DLC                 : 4;
        volatile unsigned : 1;
        volatile unsigned : 1;
        volatile unsigned : 1;
    };
    struct {
        volatile unsigned                     : 4;
        volatile unsigned RESRB0              : 1;
        volatile unsigned RESRB1              : 1;
        volatile unsigned TXRTR               : 1;
    };
    struct {
        volatile unsigned : 6;
        volatile unsigned RXRTR               : 1;
    };
} B0DLCbits @ 0xE25;

// Register: B0D0
extern volatile unsigned char           B0D0                @ 0xE26;
// bit and bitfield definitions
extern volatile bit B0D00               @ ((unsigned)&B0D0*8)+0;
extern volatile bit B0D01               @ ((unsigned)&B0D0*8)+1;
extern volatile bit B0D02               @ ((unsigned)&B0D0*8)+2;
extern volatile bit B0D03               @ ((unsigned)&B0D0*8)+3;
extern volatile bit B0D04               @ ((unsigned)&B0D0*8)+4;
extern volatile bit B0D05               @ ((unsigned)&B0D0*8)+5;
extern volatile bit B0D06               @ ((unsigned)&B0D0*8)+6;
extern volatile bit B0D07               @ ((unsigned)&B0D0*8)+7;
extern union {
    struct {
        volatile unsigned B0D00               : 1;
        volatile unsigned B0D01               : 1;
        volatile unsigned B0D02               : 1;
        volatile unsigned B0D03               : 1;
        volatile unsigned B0D04               : 1;
        volatile unsigned B0D05               : 1;
        volatile unsigned B0D06               : 1;
        volatile unsigned B0D07               : 1;
    };
} B0D0bits @ 0xE26;

// Register: B0D1
extern volatile unsigned char           B0D1                @ 0xE27;
// bit and bitfield definitions
extern volatile bit B0D10               @ ((unsigned)&B0D1*8)+0;
extern volatile bit B0D11               @ ((unsigned)&B0D1*8)+1;
extern volatile bit B0D12               @ ((unsigned)&B0D1*8)+2;
extern volatile bit B0D13               @ ((unsigned)&B0D1*8)+3;
extern volatile bit B0D14               @ ((unsigned)&B0D1*8)+4;
extern volatile bit B0D15               @ ((unsigned)&B0D1*8)+5;
extern volatile bit B0D16               @ ((unsigned)&B0D1*8)+6;
extern volatile bit B0D17               @ ((unsigned)&B0D1*8)+7;
extern union {
    struct {
        volatile unsigned B0D10               : 1;
        volatile unsigned B0D11               : 1;
        volatile unsigned B0D12               : 1;
        volatile unsigned B0D13               : 1;
        volatile unsigned B0D14               : 1;
        volatile unsigned B0D15               : 1;
        volatile unsigned B0D16               : 1;
        volatile unsigned B0D17               : 1;
    };
} B0D1bits @ 0xE27;

// Register: B0D2
extern volatile unsigned char           B0D2                @ 0xE28;
// bit and bitfield definitions
extern volatile bit B0D20               @ ((unsigned)&B0D2*8)+0;
extern volatile bit B0D21               @ ((unsigned)&B0D2*8)+1;
extern volatile bit B0D22               @ ((unsigned)&B0D2*8)+2;
extern volatile bit B0D23               @ ((unsigned)&B0D2*8)+3;
extern volatile bit B0D24               @ ((unsigned)&B0D2*8)+4;
extern volatile bit B0D25               @ ((unsigned)&B0D2*8)+5;
extern volatile bit B0D26               @ ((unsigned)&B0D2*8)+6;
extern volatile bit B0D27               @ ((unsigned)&B0D2*8)+7;
extern union {
    struct {
        volatile unsigned B0D20               : 1;
        volatile unsigned B0D21               : 1;
        volatile unsigned B0D22               : 1;
        volatile unsigned B0D23               : 1;
        volatile unsigned B0D24               : 1;
        volatile unsigned B0D25               : 1;
        volatile unsigned B0D26               : 1;
        volatile unsigned B0D27               : 1;
    };
} B0D2bits @ 0xE28;

// Register: B0D3
extern volatile unsigned char           B0D3                @ 0xE29;
// bit and bitfield definitions
extern volatile bit B0D30               @ ((unsigned)&B0D3*8)+0;
extern volatile bit B0D31               @ ((unsigned)&B0D3*8)+1;
extern volatile bit B0D32               @ ((unsigned)&B0D3*8)+2;
extern volatile bit B0D33               @ ((unsigned)&B0D3*8)+3;
extern volatile bit B0D34               @ ((unsigned)&B0D3*8)+4;
extern volatile bit B0D35               @ ((unsigned)&B0D3*8)+5;
extern volatile bit B0D36               @ ((unsigned)&B0D3*8)+6;
extern volatile bit B0D37               @ ((unsigned)&B0D3*8)+7;
extern union {
    struct {
        volatile unsigned B0D30               : 1;
        volatile unsigned B0D31               : 1;
        volatile unsigned B0D32               : 1;
        volatile unsigned B0D33               : 1;
        volatile unsigned B0D34               : 1;
        volatile unsigned B0D35               : 1;
        volatile unsigned B0D36               : 1;
        volatile unsigned B0D37               : 1;
    };
} B0D3bits @ 0xE29;

// Register: B0D4
extern volatile unsigned char           B0D4                @ 0xE2A;
// bit and bitfield definitions
extern volatile bit B0D40               @ ((unsigned)&B0D4*8)+0;
extern volatile bit B0D41               @ ((unsigned)&B0D4*8)+1;
extern volatile bit B0D42               @ ((unsigned)&B0D4*8)+2;
extern volatile bit B0D43               @ ((unsigned)&B0D4*8)+3;
extern volatile bit B0D44               @ ((unsigned)&B0D4*8)+4;
extern volatile bit B0D45               @ ((unsigned)&B0D4*8)+5;
extern volatile bit B0D46               @ ((unsigned)&B0D4*8)+6;
extern volatile bit B0D47               @ ((unsigned)&B0D4*8)+7;
extern union {
    struct {
        volatile unsigned B0D40               : 1;
        volatile unsigned B0D41               : 1;
        volatile unsigned B0D42               : 1;
        volatile unsigned B0D43               : 1;
        volatile unsigned B0D44               : 1;
        volatile unsigned B0D45               : 1;
        volatile unsigned B0D46               : 1;
        volatile unsigned B0D47               : 1;
    };
} B0D4bits @ 0xE2A;

// Register: B0D5
extern volatile unsigned char           B0D5                @ 0xE2B;
// bit and bitfield definitions
extern volatile bit B0D50               @ ((unsigned)&B0D5*8)+0;
extern volatile bit B0D51               @ ((unsigned)&B0D5*8)+1;
extern volatile bit B0D52               @ ((unsigned)&B0D5*8)+2;
extern volatile bit B0D53               @ ((unsigned)&B0D5*8)+3;
extern volatile bit B0D54               @ ((unsigned)&B0D5*8)+4;
extern volatile bit B0D55               @ ((unsigned)&B0D5*8)+5;
extern volatile bit B0D56               @ ((unsigned)&B0D5*8)+6;
extern volatile bit B0D57               @ ((unsigned)&B0D5*8)+7;
extern union {
    struct {
        volatile unsigned B0D50               : 1;
        volatile unsigned B0D51               : 1;
        volatile unsigned B0D52               : 1;
        volatile unsigned B0D53               : 1;
        volatile unsigned B0D54               : 1;
        volatile unsigned B0D55               : 1;
        volatile unsigned B0D56               : 1;
        volatile unsigned B0D57               : 1;
    };
} B0D5bits @ 0xE2B;

// Register: B0D6
extern volatile unsigned char           B0D6                @ 0xE2C;
// bit and bitfield definitions
extern volatile bit B0D60               @ ((unsigned)&B0D6*8)+0;
extern volatile bit B0D61               @ ((unsigned)&B0D6*8)+1;
extern volatile bit B0D62               @ ((unsigned)&B0D6*8)+2;
extern volatile bit B0D63               @ ((unsigned)&B0D6*8)+3;
extern volatile bit B0D64               @ ((unsigned)&B0D6*8)+4;
extern volatile bit B0D65               @ ((unsigned)&B0D6*8)+5;
extern volatile bit B0D66               @ ((unsigned)&B0D6*8)+6;
extern volatile bit B0D67               @ ((unsigned)&B0D6*8)+7;
extern union {
    struct {
        volatile unsigned B0D60               : 1;
        volatile unsigned B0D61               : 1;
        volatile unsigned B0D62               : 1;
        volatile unsigned B0D63               : 1;
        volatile unsigned B0D64               : 1;
        volatile unsigned B0D65               : 1;
        volatile unsigned B0D66               : 1;
        volatile unsigned B0D67               : 1;
    };
} B0D6bits @ 0xE2C;

// Register: B0D7
extern volatile unsigned char           B0D7                @ 0xE2D;
// bit and bitfield definitions
extern volatile bit B0D70               @ ((unsigned)&B0D7*8)+0;
extern volatile bit B0D71               @ ((unsigned)&B0D7*8)+1;
extern volatile bit B0D72               @ ((unsigned)&B0D7*8)+2;
extern volatile bit B0D73               @ ((unsigned)&B0D7*8)+3;
extern volatile bit B0D74               @ ((unsigned)&B0D7*8)+4;
extern volatile bit B0D75               @ ((unsigned)&B0D7*8)+5;
extern volatile bit B0D76               @ ((unsigned)&B0D7*8)+6;
extern volatile bit B0D77               @ ((unsigned)&B0D7*8)+7;
extern union {
    struct {
        volatile unsigned B0D70               : 1;
        volatile unsigned B0D71               : 1;
        volatile unsigned B0D72               : 1;
        volatile unsigned B0D73               : 1;
        volatile unsigned B0D74               : 1;
        volatile unsigned B0D75               : 1;
        volatile unsigned B0D76               : 1;
        volatile unsigned B0D77               : 1;
    };
} B0D7bits @ 0xE2D;

// Register: CANSTAT_RO9
extern volatile unsigned char           CANSTAT_RO9         @ 0xE2E;
// bit and bitfield definitions
//extern volatile bit EICODE0            @ ((unsigned)&CANSTAT_RO9*8)+0;
//extern volatile bit EICODE1_ICODE0     @ ((unsigned)&CANSTAT_RO9*8)+1;
//extern volatile bit EICODE2_ICODE1     @ ((unsigned)&CANSTAT_RO9*8)+2;
//extern volatile bit EICODE3_ICODE2     @ ((unsigned)&CANSTAT_RO9*8)+3;
//extern volatile bit EICODE4            @ ((unsigned)&CANSTAT_RO9*8)+4;
//extern volatile bit OPMODE0            @ ((unsigned)&CANSTAT_RO9*8)+5;
//extern volatile bit OPMODE1            @ ((unsigned)&CANSTAT_RO9*8)+6;
//extern volatile bit OPMODE2            @ ((unsigned)&CANSTAT_RO9*8)+7;
//extern volatile bit ICODE0             @ ((unsigned)&CANSTAT_RO9*8)+0;
//extern volatile bit ICODE1             @ ((unsigned)&CANSTAT_RO9*8)+1;
//extern volatile bit ICODE2             @ ((unsigned)&CANSTAT_RO9*8)+2;
//extern volatile bit ICODE3             @ ((unsigned)&CANSTAT_RO9*8)+3;
//extern volatile bit ICODE4             @ ((unsigned)&CANSTAT_RO9*8)+4;
extern union {
    struct {
        volatile unsigned EICODE0             : 1;
        volatile unsigned EICODE1_ICODE0      : 1;
        volatile unsigned EICODE2_ICODE1      : 1;
        volatile unsigned EICODE3_ICODE2      : 1;
        volatile unsigned EICODE4             : 1;
        volatile unsigned OPMODE0             : 1;
        volatile unsigned OPMODE1             : 1;
        volatile unsigned OPMODE2             : 1;
    };
    struct {
        volatile unsigned : 1;
        volatile unsigned : 1;
        volatile unsigned : 1;
        volatile unsigned : 1;
        volatile unsigned : 1;
        volatile unsigned OPMODE              : 3;
    };
    struct {
        volatile unsigned ICODE0              : 1;
        volatile unsigned ICODE1              : 1;
        volatile unsigned ICODE2              : 1;
        volatile unsigned ICODE3              : 1;
        volatile unsigned ICODE4              : 1;
    };
} CANSTAT_RO9bits @ 0xE2E;

// Register: CANCON_RO9
extern volatile unsigned char           CANCON_RO9          @ 0xE2F;
// bit and bitfield definitions
//extern volatile bit FP0                @ ((unsigned)&CANCON_RO9*8)+0;
//extern volatile bit WIN0_FP1           @ ((unsigned)&CANCON_RO9*8)+1;
//extern volatile bit WIN1_FP2           @ ((unsigned)&CANCON_RO9*8)+2;
//extern volatile bit WIN2_FP3           @ ((unsigned)&CANCON_RO9*8)+3;
//extern volatile bit ABAT               @ ((unsigned)&CANCON_RO9*8)+4;
//extern volatile bit REQOP0             @ ((unsigned)&CANCON_RO9*8)+5;
//extern volatile bit REQOP1             @ ((unsigned)&CANCON_RO9*8)+6;
//extern volatile bit REQOP2             @ ((unsigned)&CANCON_RO9*8)+7;
//extern volatile bit WIN0               @ ((unsigned)&CANCON_RO9*8)+1;
//extern volatile bit WIN1               @ ((unsigned)&CANCON_RO9*8)+2;
//extern volatile bit WIN2               @ ((unsigned)&CANCON_RO9*8)+3;
extern union {
    struct {
        volatile unsigned FP0                 : 1;
        volatile unsigned WIN0_FP1            : 1;
        volatile unsigned WIN1_FP2            : 1;
        volatile unsigned WIN2_FP3            : 1;
        volatile unsigned ABAT                : 1;
        volatile unsigned REQOP0              : 1;
        volatile unsigned REQOP1              : 1;
        volatile unsigned REQOP2              : 1;
    };
    struct {
        volatile unsigned : 1;
        volatile unsigned : 1;
        volatile unsigned : 1;
        volatile unsigned : 1;
        volatile unsigned : 1;
        volatile unsigned REQOP               : 3;
    };
    struct {
        volatile unsigned                     : 1;
        volatile unsigned WIN0                : 1;
        volatile unsigned WIN1                : 1;
        volatile unsigned WIN2                : 1;
    };
} CANCON_RO9bits @ 0xE2F;

// Register: B1CON
extern volatile unsigned char           B1CON               @ 0xE30;
// bit and bitfield definitions
//extern volatile bit FILHIT0_TXPRI0     @ ((unsigned)&B1CON*8)+0;
//extern volatile bit FILHIT1_TXPRI1     @ ((unsigned)&B1CON*8)+1;
//extern volatile bit FILHIT2_RTREN      @ ((unsigned)&B1CON*8)+2;
//extern volatile bit FILHIT3_TXREQ      @ ((unsigned)&B1CON*8)+3;
//extern volatile bit FILHIT4_TXERR      @ ((unsigned)&B1CON*8)+4;
//extern volatile bit RXRTRRO_TXLARB     @ ((unsigned)&B1CON*8)+5;
//extern volatile bit RXM1_TXABT         @ ((unsigned)&B1CON*8)+6;
//extern volatile bit RXFUL_TXBIF        @ ((unsigned)&B1CON*8)+7;
//extern volatile bit FILHIT0            @ ((unsigned)&B1CON*8)+0;
//extern volatile bit FILHIT1            @ ((unsigned)&B1CON*8)+1;
//extern volatile bit FILHIT2            @ ((unsigned)&B1CON*8)+2;
//extern volatile bit FILHIT3            @ ((unsigned)&B1CON*8)+3;
//extern volatile bit FILHIT4            @ ((unsigned)&B1CON*8)+4;
//extern volatile bit RTRRO              @ ((unsigned)&B1CON*8)+5;
//extern volatile bit RXM1               @ ((unsigned)&B1CON*8)+6;
//extern volatile bit RXFUL              @ ((unsigned)&B1CON*8)+7;
//extern volatile bit TXPRI0             @ ((unsigned)&B1CON*8)+0;
//extern volatile bit TXPRI1             @ ((unsigned)&B1CON*8)+1;
//extern volatile bit RTREN              @ ((unsigned)&B1CON*8)+2;
//extern volatile bit TXREQ              @ ((unsigned)&B1CON*8)+3;
//extern volatile bit TXERR              @ ((unsigned)&B1CON*8)+4;
//extern volatile bit TXLARB             @ ((unsigned)&B1CON*8)+5;
//extern volatile bit TXABT              @ ((unsigned)&B1CON*8)+6;
//extern volatile bit TXBIF              @ ((unsigned)&B1CON*8)+7;
//extern volatile bit RXRTRRO            @ ((unsigned)&B1CON*8)+5;
extern union {
    struct {
        volatile unsigned FILHIT0_TXPRI0      : 1;
        volatile unsigned FILHIT1_TXPRI1      : 1;
        volatile unsigned FILHIT2_RTREN       : 1;
        volatile unsigned FILHIT3_TXREQ       : 1;
        volatile unsigned FILHIT4_TXERR       : 1;
        volatile unsigned RXRTRRO_TXLARB      : 1;
        volatile unsigned RXM1_TXABT          : 1;
        volatile unsigned RXFUL_TXBIF         : 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 FILHIT0             : 1;
        volatile unsigned FILHIT1             : 1;
        volatile unsigned FILHIT2             : 1;
        volatile unsigned FILHIT3             : 1;
        volatile unsigned FILHIT4             : 1;
        volatile unsigned RTRRO               : 1;
        volatile unsigned RXM1                : 1;
        volatile unsigned RXFUL               : 1;
    };
    struct {
        volatile unsigned TXPRI0              : 1;
        volatile unsigned TXPRI1              : 1;
        volatile unsigned RTREN               : 1;
        volatile unsigned TXREQ               : 1;
        volatile unsigned TXERR               : 1;
        volatile unsigned TXLARB              : 1;
        volatile unsigned TXABT               : 1;
        volatile unsigned TXBIF               : 1;
    };
    struct {
        volatile unsigned                     : 5;
        volatile unsigned RXRTRRO             : 1;
    };
} B1CONbits @ 0xE30;

// Register: B1SIDH
extern volatile unsigned char           B1SIDH              @ 0xE31;
// bit and bitfield definitions
//extern volatile bit SID3               @ ((unsigned)&B1SIDH*8)+0;
//extern volatile bit SID4               @ ((unsigned)&B1SIDH*8)+1;
//extern volatile bit SID5               @ ((unsigned)&B1SIDH*8)+2;
//extern volatile bit SID6               @ ((unsigned)&B1SIDH*8)+3;
//extern volatile bit SID7               @ ((unsigned)&B1SIDH*8)+4;
//extern volatile bit SID8               @ ((unsigned)&B1SIDH*8)+5;
//extern volatile bit SID9               @ ((unsigned)&B1SIDH*8)+6;
//extern volatile bit SID10              @ ((unsigned)&B1SIDH*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;
    };
} B1SIDHbits @ 0xE31;

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

// Register: B1EIDH
extern volatile unsigned char           B1EIDH              @ 0xE33;
// bit and bitfield definitions
//extern volatile bit EID8               @ ((unsigned)&B1EIDH*8)+0;
//extern volatile bit EID9               @ ((unsigned)&B1EIDH*8)+1;
//extern volatile bit EID10              @ ((unsigned)&B1EIDH*8)+2;
//extern volatile bit EID11              @ ((unsigned)&B1EIDH*8)+3;
//extern volatile bit EID12              @ ((unsigned)&B1EIDH*8)+4;
//extern volatile bit EID13              @ ((unsigned)&B1EIDH*8)+5;
//extern volatile bit EID14              @ ((unsigned)&B1EIDH*8)+6;
//extern volatile bit EID15              @ ((unsigned)&B1EIDH*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;
    };
} B1EIDHbits @ 0xE33;

// Register: B1EIDL
extern volatile unsigned char           B1EIDL              @ 0xE34;
// bit and bitfield definitions
//extern volatile bit EID0               @ ((unsigned)&B1EIDL*8)+0;
//extern volatile bit EID1               @ ((unsigned)&B1EIDL*8)+1;
//extern volatile bit EID2               @ ((unsigned)&B1EIDL*8)+2;
//extern volatile bit EID3               @ ((unsigned)&B1EIDL*8)+3;
//extern volatile bit EID4               @ ((unsigned)&B1EIDL*8)+4;
//extern volatile bit EID5               @ ((unsigned)&B1EIDL*8)+5;
//extern volatile bit EID6               @ ((unsigned)&B1EIDL*8)+6;
//extern volatile bit EID7               @ ((unsigned)&B1EIDL*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;
    };
} B1EIDLbits @ 0xE34;

// Register: B1DLC
extern volatile unsigned char           B1DLC               @ 0xE35;
// bit and bitfield definitions
//extern volatile bit DLC0               @ ((unsigned)&B1DLC*8)+0;
//extern volatile bit DLC1               @ ((unsigned)&B1DLC*8)+1;
//extern volatile bit DLC2               @ ((unsigned)&B1DLC*8)+2;
//extern volatile bit DLC3               @ ((unsigned)&B1DLC*8)+3;
//extern volatile bit RB0                @ ((unsigned)&B1DLC*8)+4;
//extern volatile bit RB1                @ ((unsigned)&B1DLC*8)+5;
//extern volatile bit RXRTR_TXRTR        @ ((unsigned)&B1DLC*8)+6;
//extern volatile bit RESRB0             @ ((unsigned)&B1DLC*8)+4;
//extern volatile bit RESRB1             @ ((unsigned)&B1DLC*8)+5;
//extern volatile bit TXRTR              @ ((unsigned)&B1DLC*8)+6;
//extern volatile bit RXRTR              @ ((unsigned)&B1DLC*8)+6;
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_TXRTR         : 1;
    };
    struct {
        volatile unsigned DLC                 : 4;
        volatile unsigned : 1;
        volatile unsigned : 1;
        volatile unsigned : 1;
    };
    struct {
        volatile unsigned                     : 4;
        volatile unsigned RESRB0              : 1;
        volatile unsigned RESRB1              : 1;
        volatile unsigned TXRTR               : 1;
    };
    struct {
        volatile unsigned : 6;
        volatile unsigned RXRTR               : 1;
    };
} B1DLCbits @ 0xE35;

// Register: B1D0
extern volatile unsigned char           B1D0                @ 0xE36;
// bit and bitfield definitions
extern volatile bit B1D00               @ ((unsigned)&B1D0*8)+0;
extern volatile bit B1D01               @ ((unsigned)&B1D0*8)+1;
extern volatile bit B1D02               @ ((unsigned)&B1D0*8)+2;
extern volatile bit B1D03               @ ((unsigned)&B1D0*8)+3;
extern volatile bit B1D04               @ ((unsigned)&B1D0*8)+4;
extern volatile bit B1D05               @ ((unsigned)&B1D0*8)+5;
extern volatile bit B1D06               @ ((unsigned)&B1D0*8)+6;
extern volatile bit B1D07               @ ((unsigned)&B1D0*8)+7;
extern union {
    struct {
        volatile unsigned B1D00               : 1;
        volatile unsigned B1D01               : 1;
        volatile unsigned B1D02               : 1;
        volatile unsigned B1D03               : 1;
        volatile unsigned B1D04               : 1;
        volatile unsigned B1D05               : 1;
        volatile unsigned B1D06               : 1;
        volatile unsigned B1D07               : 1;
    };
} B1D0bits @ 0xE36;

// Register: B1D1
extern volatile unsigned char           B1D1                @ 0xE37;
// bit and bitfield definitions
extern volatile bit B1D10               @ ((unsigned)&B1D1*8)+0;
extern volatile bit B1D11               @ ((unsigned)&B1D1*8)+1;
extern volatile bit B1D12               @ ((unsigned)&B1D1*8)+2;
extern volatile bit B1D13               @ ((unsigned)&B1D1*8)+3;
extern volatile bit B1D14               @ ((unsigned)&B1D1*8)+4;
extern volatile bit B1D15               @ ((unsigned)&B1D1*8)+5;
extern volatile bit B1D16               @ ((unsigned)&B1D1*8)+6;
extern volatile bit B1D17               @ ((unsigned)&B1D1*8)+7;
extern union {
    struct {
        volatile unsigned B1D10               : 1;
        volatile unsigned B1D11               : 1;
        volatile unsigned B1D12               : 1;
        volatile unsigned B1D13               : 1;
        volatile unsigned B1D14               : 1;
        volatile unsigned B1D15               : 1;
        volatile unsigned B1D16               : 1;
        volatile unsigned B1D17               : 1;
    };
} B1D1bits @ 0xE37;

// Register: B1D2
extern volatile unsigned char           B1D2                @ 0xE38;
// bit and bitfield definitions
extern volatile bit B1D20               @ ((unsigned)&B1D2*8)+0;
extern volatile bit B1D21               @ ((unsigned)&B1D2*8)+1;
extern volatile bit B1D22               @ ((unsigned)&B1D2*8)+2;
extern volatile bit B1D23               @ ((unsigned)&B1D2*8)+3;
extern volatile bit B1D24               @ ((unsigned)&B1D2*8)+4;
extern volatile bit B1D25               @ ((unsigned)&B1D2*8)+5;
extern volatile bit B1D26               @ ((unsigned)&B1D2*8)+6;
extern volatile bit B1D27               @ ((unsigned)&B1D2*8)+7;
extern union {
    struct {
        volatile unsigned B1D20               : 1;
        volatile unsigned B1D21               : 1;
        volatile unsigned B1D22               : 1;
        volatile unsigned B1D23               : 1;
        volatile unsigned B1D24               : 1;
        volatile unsigned B1D25               : 1;
        volatile unsigned B1D26               : 1;
        volatile unsigned B1D27               : 1;
    };
} B1D2bits @ 0xE38;

// Register: B1D3
extern volatile unsigned char           B1D3                @ 0xE39;
// bit and bitfield definitions
extern volatile bit B1D30               @ ((unsigned)&B1D3*8)+0;
extern volatile bit B1D31               @ ((unsigned)&B1D3*8)+1;
extern volatile bit B1D32               @ ((unsigned)&B1D3*8)+2;
extern volatile bit B1D33               @ ((unsigned)&B1D3*8)+3;
extern volatile bit B1D34               @ ((unsigned)&B1D3*8)+4;
extern volatile bit B1D35               @ ((unsigned)&B1D3*8)+5;
extern volatile bit B1D36               @ ((unsigned)&B1D3*8)+6;
extern volatile bit B1D37               @ ((unsigned)&B1D3*8)+7;
extern union {
    struct {
        volatile unsigned B1D30               : 1;
        volatile unsigned B1D31               : 1;
        volatile unsigned B1D32               : 1;
        volatile unsigned B1D33               : 1;
        volatile unsigned B1D34               : 1;
        volatile unsigned B1D35               : 1;
        volatile unsigned B1D36               : 1;
        volatile unsigned B1D37               : 1;
    };
} B1D3bits @ 0xE39;

// Register: B1D4
extern volatile unsigned char           B1D4                @ 0xE3A;
// bit and bitfield definitions
extern volatile bit B1D40               @ ((unsigned)&B1D4*8)+0;
extern volatile bit B1D41               @ ((unsigned)&B1D4*8)+1;
extern volatile bit B1D42               @ ((unsigned)&B1D4*8)+2;
extern volatile bit B1D43               @ ((unsigned)&B1D4*8)+3;
extern volatile bit B1D44               @ ((unsigned)&B1D4*8)+4;
extern volatile bit B1D45               @ ((unsigned)&B1D4*8)+5;
extern volatile bit B1D46               @ ((unsigned)&B1D4*8)+6;
extern volatile bit B1D47               @ ((unsigned)&B1D4*8)+7;
extern union {
    struct {
        volatile unsigned B1D40               : 1;
        volatile unsigned B1D41               : 1;
        volatile unsigned B1D42               : 1;
        volatile unsigned B1D43               : 1;
        volatile unsigned B1D44               : 1;
        volatile unsigned B1D45               : 1;
        volatile unsigned B1D46               : 1;
        volatile unsigned B1D47               : 1;
    };
} B1D4bits @ 0xE3A;

// Register: B1D5
extern volatile unsigned char           B1D5                @ 0xE3B;
// bit and bitfield definitions
extern volatile bit B1D50               @ ((unsigned)&B1D5*8)+0;
extern volatile bit B1D51               @ ((unsigned)&B1D5*8)+1;
extern volatile bit B1D52               @ ((unsigned)&B1D5*8)+2;
extern volatile bit B1D53               @ ((unsigned)&B1D5*8)+3;
extern volatile bit B1D54               @ ((unsigned)&B1D5*8)+4;
extern volatile bit B1D55               @ ((unsigned)&B1D5*8)+5;
extern volatile bit B1D56               @ ((unsigned)&B1D5*8)+6;
extern volatile bit B1D57               @ ((unsigned)&B1D5*8)+7;
extern union {
    struct {
        volatile unsigned B1D50               : 1;
        volatile unsigned B1D51               : 1;
        volatile unsigned B1D52               : 1;
        volatile unsigned B1D53               : 1;
        volatile unsigned B1D54               : 1;
        volatile unsigned B1D55               : 1;
        volatile unsigned B1D56               : 1;
        volatile unsigned B1D57               : 1;
    };
} B1D5bits @ 0xE3B;

// Register: B1D6
extern volatile unsigned char           B1D6                @ 0xE3C;
// bit and bitfield definitions
extern volatile bit B1D60               @ ((unsigned)&B1D6*8)+0;
extern volatile bit B1D61               @ ((unsigned)&B1D6*8)+1;
extern volatile bit B1D62               @ ((unsigned)&B1D6*8)+2;
extern volatile bit B1D63               @ ((unsigned)&B1D6*8)+3;
extern volatile bit B1D64               @ ((unsigned)&B1D6*8)+4;
extern volatile bit B1D65               @ ((unsigned)&B1D6*8)+5;
extern volatile bit B1D66               @ ((unsigned)&B1D6*8)+6;
extern volatile bit B1D67               @ ((unsigned)&B1D6*8)+7;
extern union {
    struct {
        volatile unsigned B1D60               : 1;
        volatile unsigned B1D61               : 1;
        volatile unsigned B1D62               : 1;
        volatile unsigned B1D63               : 1;
        volatile unsigned B1D64               : 1;
        volatile unsigned B1D65               : 1;
        volatile unsigned B1D66               : 1;
        volatile unsigned B1D67               : 1;
    };
} B1D6bits @ 0xE3C;

// Register: B1D7
extern volatile unsigned char           B1D7                @ 0xE3D;
// bit and bitfield definitions
extern volatile bit B1D70               @ ((unsigned)&B1D7*8)+0;
extern volatile bit B1D71               @ ((unsigned)&B1D7*8)+1;
extern volatile bit B1D72               @ ((unsigned)&B1D7*8)+2;
extern volatile bit B1D73               @ ((unsigned)&B1D7*8)+3;
extern volatile bit B1D74               @ ((unsigned)&B1D7*8)+4;
extern volatile bit B1D75               @ ((unsigned)&B1D7*8)+5;
extern volatile bit B1D76               @ ((unsigned)&B1D7*8)+6;
extern volatile bit B1D77               @ ((unsigned)&B1D7*8)+7;
extern union {
    struct {
        volatile unsigned B1D70               : 1;
        volatile unsigned B1D71               : 1;
        volatile unsigned B1D72               : 1;
        volatile unsigned B1D73               : 1;
        volatile unsigned B1D74               : 1;
        volatile unsigned B1D75               : 1;
        volatile unsigned B1D76               : 1;
        volatile unsigned B1D77               : 1;
    };
} B1D7bits @ 0xE3D;

// Register: CANSTAT_RO8
extern volatile unsigned char           CANSTAT_RO8         @ 0xE3E;
// bit and bitfield definitions
//extern volatile bit EICODE0            @ ((unsigned)&CANSTAT_RO8*8)+0;
//extern volatile bit EICODE1_ICODE0     @ ((unsigned)&CANSTAT_RO8*8)+1;
//extern volatile bit EICODE2_ICODE1     @ ((unsigned)&CANSTAT_RO8*8)+2;
//extern volatile bit EICODE3_ICODE2     @ ((unsigned)&CANSTAT_RO8*8)+3;
//extern volatile bit EICODE4            @ ((unsigned)&CANSTAT_RO8*8)+4;
//extern volatile bit OPMODE0            @ ((unsigned)&CANSTAT_RO8*8)+5;
//extern volatile bit OPMODE1            @ ((unsigned)&CANSTAT_RO8*8)+6;
//extern volatile bit OPMODE2            @ ((unsigned)&CANSTAT_RO8*8)+7;
//extern volatile bit ICODE0             @ ((unsigned)&CANSTAT_RO8*8)+0;
//extern volatile bit ICODE1             @ ((unsigned)&CANSTAT_RO8*8)+1;
//extern volatile bit ICODE2             @ ((unsigned)&CANSTAT_RO8*8)+2;
//extern volatile bit ICODE3             @ ((unsigned)&CANSTAT_RO8*8)+3;
//extern volatile bit ICODE4             @ ((unsigned)&CANSTAT_RO8*8)+4;
extern union {
    struct {
        volatile unsigned EICODE0             : 1;
        volatile unsigned EICODE1_ICODE0      : 1;
        volatile unsigned EICODE2_ICODE1      : 1;
        volatile unsigned EICODE3_ICODE2      : 1;
        volatile unsigned EICODE4             : 1;
        volatile unsigned OPMODE0             : 1;
        volatile unsigned OPMODE1             : 1;
        volatile unsigned OPMODE2             : 1;
    };
    struct {
        volatile unsigned : 1;
        volatile unsigned : 1;
        volatile unsigned : 1;
        volatile unsigned : 1;
        volatile unsigned : 1;
        volatile unsigned OPMODE              : 3;
    };
    struct {
        volatile unsigned ICODE0              : 1;
        volatile unsigned ICODE1              : 1;
        volatile unsigned ICODE2              : 1;
        volatile unsigned ICODE3              : 1;
        volatile unsigned ICODE4              : 1;
    };
} CANSTAT_RO8bits @ 0xE3E;

// Register: CANCON_RO8
extern volatile unsigned char           CANCON_RO8          @ 0xE3F;
// bit and bitfield definitions
//extern volatile bit FP0                @ ((unsigned)&CANCON_RO8*8)+0;
//extern volatile bit WIN0_FP1           @ ((unsigned)&CANCON_RO8*8)+1;
//extern volatile bit WIN1_FP2           @ ((unsigned)&CANCON_RO8*8)+2;
//extern volatile bit WIN2_FP3           @ ((unsigned)&CANCON_RO8*8)+3;
//extern volatile bit ABAT               @ ((unsigned)&CANCON_RO8*8)+4;
//extern volatile bit REQOP0             @ ((unsigned)&CANCON_RO8*8)+5;
//extern volatile bit REQOP1             @ ((unsigned)&CANCON_RO8*8)+6;
//extern volatile bit REQOP2             @ ((unsigned)&CANCON_RO8*8)+7;
//extern volatile bit WIN0               @ ((unsigned)&CANCON_RO8*8)+1;
//extern volatile bit WIN1               @ ((unsigned)&CANCON_RO8*8)+2;
//extern volatile bit WIN2               @ ((unsigned)&CANCON_RO8*8)+3;
extern union {
    struct {
        volatile unsigned FP0                 : 1;
        volatile unsigned WIN0_FP1            : 1;
        volatile unsigned WIN1_FP2            : 1;
        volatile unsigned WIN2_FP3            : 1;
        volatile unsigned ABAT                : 1;
        volatile unsigned REQOP0              : 1;
        volatile unsigned REQOP1              : 1;
        volatile unsigned REQOP2              : 1;
    };
    struct {
        volatile unsigned : 1;
        volatile unsigned : 1;
        volatile unsigned : 1;
        volatile unsigned : 1;
        volatile unsigned : 1;
        volatile unsigned REQOP               : 3;
    };
    struct {
        volatile unsigned                     : 1;
        volatile unsigned WIN0                : 1;
        volatile unsigned WIN1                : 1;
        volatile unsigned WIN2                : 1;
    };
} CANCON_RO8bits @ 0xE3F;

// Register: B2CON
extern volatile unsigned char           B2CON               @ 0xE40;
// bit and bitfield definitions
//extern volatile bit FILHIT0_TXPRI0     @ ((unsigned)&B2CON*8)+0;
//extern volatile bit FILHIT1_TXPRI1     @ ((unsigned)&B2CON*8)+1;
//extern volatile bit FILHIT2_RTREN      @ ((unsigned)&B2CON*8)+2;
//extern volatile bit FILHIT3_TXREQ      @ ((unsigned)&B2CON*8)+3;
//extern volatile bit FILHIT4_TXERR      @ ((unsigned)&B2CON*8)+4;
//extern volatile bit RXRTRRO_TXLARB     @ ((unsigned)&B2CON*8)+5;
//extern volatile bit RXM1_TXABT         @ ((unsigned)&B2CON*8)+6;
//extern volatile bit RXFUL_TXBIF        @ ((unsigned)&B2CON*8)+7;
//extern volatile bit FILHIT0            @ ((unsigned)&B2CON*8)+0;
//extern volatile bit FILHIT1            @ ((unsigned)&B2CON*8)+1;
//extern volatile bit FILHIT2            @ ((unsigned)&B2CON*8)+2;
//extern volatile bit FILHIT3            @ ((unsigned)&B2CON*8)+3;
//extern volatile bit FILHIT4            @ ((unsigned)&B2CON*8)+4;
//extern volatile bit RTRRO              @ ((unsigned)&B2CON*8)+5;
//extern volatile bit RXM1               @ ((unsigned)&B2CON*8)+6;
//extern volatile bit RXFUL              @ ((unsigned)&B2CON*8)+7;
//extern volatile bit TXPRI0             @ ((unsigned)&B2CON*8)+0;
//extern volatile bit TXPRI1             @ ((unsigned)&B2CON*8)+1;
//extern volatile bit RTREN              @ ((unsigned)&B2CON*8)+2;
//extern volatile bit TXREQ              @ ((unsigned)&B2CON*8)+3;
//extern volatile bit TXERR              @ ((unsigned)&B2CON*8)+4;
//extern volatile bit TXLARB             @ ((unsigned)&B2CON*8)+5;
//extern volatile bit TXABT              @ ((unsigned)&B2CON*8)+6;
//extern volatile bit TXBIF              @ ((unsigned)&B2CON*8)+7;
//extern volatile bit RXRTRRO            @ ((unsigned)&B2CON*8)+5;
extern union {
    struct {
        volatile unsigned FILHIT0_TXPRI0      : 1;
        volatile unsigned FILHIT1_TXPRI1      : 1;
        volatile unsigned FILHIT2_RTREN       : 1;
        volatile unsigned FILHIT3_TXREQ       : 1;
        volatile unsigned FILHIT4_TXERR       : 1;
        volatile unsigned RXRTRRO_TXLARB      : 1;
        volatile unsigned RXM1_TXABT          : 1;
        volatile unsigned RXFUL_TXBIF         : 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 FILHIT0             : 1;
        volatile unsigned FILHIT1             : 1;
        volatile unsigned FILHIT2             : 1;
        volatile unsigned FILHIT3             : 1;
        volatile unsigned FILHIT4             : 1;
        volatile unsigned RTRRO               : 1;
        volatile unsigned RXM1                : 1;
        volatile unsigned RXFUL               : 1;
    };
    struct {
        volatile unsigned TXPRI0              : 1;
        volatile unsigned TXPRI1              : 1;
        volatile unsigned RTREN               : 1;
        volatile unsigned TXREQ               : 1;
        volatile unsigned TXERR               : 1;
        volatile unsigned TXLARB              : 1;
        volatile unsigned TXABT               : 1;
        volatile unsigned TXBIF               : 1;
    };
    struct {
        volatile unsigned                     : 5;
        volatile unsigned RXRTRRO             : 1;
    };
} B2CONbits @ 0xE40;

// Register: B2SIDH
extern volatile unsigned char           B2SIDH              @ 0xE41;
// bit and bitfield definitions
//extern volatile bit SID3               @ ((unsigned)&B2SIDH*8)+0;
//extern volatile bit SID4               @ ((unsigned)&B2SIDH*8)+1;
//extern volatile bit SID5               @ ((unsigned)&B2SIDH*8)+2;
//extern volatile bit SID6               @ ((unsigned)&B2SIDH*8)+3;
//extern volatile bit SID7               @ ((unsigned)&B2SIDH*8)+4;
//extern volatile bit SID8               @ ((unsigned)&B2SIDH*8)+5;
//extern volatile bit SID9               @ ((unsigned)&B2SIDH*8)+6;
//extern volatile bit SID10              @ ((unsigned)&B2SIDH*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;
    };
} B2SIDHbits @ 0xE41;

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

// Register: B2EIDH
extern volatile unsigned char           B2EIDH              @ 0xE43;
// bit and bitfield definitions
//extern volatile bit EID8               @ ((unsigned)&B2EIDH*8)+0;
//extern volatile bit EID9               @ ((unsigned)&B2EIDH*8)+1;
//extern volatile bit EID10              @ ((unsigned)&B2EIDH*8)+2;
//extern volatile bit EID11              @ ((unsigned)&B2EIDH*8)+3;
//extern volatile bit EID12              @ ((unsigned)&B2EIDH*8)+4;
//extern volatile bit EID13              @ ((unsigned)&B2EIDH*8)+5;
//extern volatile bit EID14              @ ((unsigned)&B2EIDH*8)+6;
//extern volatile bit EID15              @ ((unsigned)&B2EIDH*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;
    };
} B2EIDHbits @ 0xE43;

// Register: B2EIDL
extern volatile unsigned char           B2EIDL              @ 0xE44;
// bit and bitfield definitions
//extern volatile bit EID0               @ ((unsigned)&B2EIDL*8)+0;
//extern volatile bit EID1               @ ((unsigned)&B2EIDL*8)+1;
//extern volatile bit EID2               @ ((unsigned)&B2EIDL*8)+2;
//extern volatile bit EID3               @ ((unsigned)&B2EIDL*8)+3;
//extern volatile bit EID4               @ ((unsigned)&B2EIDL*8)+4;
//extern volatile bit EID5               @ ((unsigned)&B2EIDL*8)+5;
//extern volatile bit EID6               @ ((unsigned)&B2EIDL*8)+6;
//extern volatile bit EID7               @ ((unsigned)&B2EIDL*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;
    };
} B2EIDLbits @ 0xE44;

// Register: B2DLC
extern volatile unsigned char           B2DLC               @ 0xE45;
// bit and bitfield definitions
//extern volatile bit DLC0               @ ((unsigned)&B2DLC*8)+0;
//extern volatile bit DLC1               @ ((unsigned)&B2DLC*8)+1;
//extern volatile bit DLC2               @ ((unsigned)&B2DLC*8)+2;
//extern volatile bit DLC3               @ ((unsigned)&B2DLC*8)+3;
//extern volatile bit RB0                @ ((unsigned)&B2DLC*8)+4;
//extern volatile bit RB1                @ ((unsigned)&B2DLC*8)+5;
//extern volatile bit RXRTR_TXRTR        @ ((unsigned)&B2DLC*8)+6;
//extern volatile bit RESRB0             @ ((unsigned)&B2DLC*8)+4;
//extern volatile bit RESRB1             @ ((unsigned)&B2DLC*8)+5;
//extern volatile bit TXRTR              @ ((unsigned)&B2DLC*8)+6;
//extern volatile bit RXRTR              @ ((unsigned)&B2DLC*8)+6;
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_TXRTR         : 1;
    };
    struct {
        volatile unsigned DLC                 : 4;
        volatile unsigned : 1;
        volatile unsigned : 1;
        volatile unsigned : 1;
    };
    struct {
        volatile unsigned                     : 4;
        volatile unsigned RESRB0              : 1;
        volatile unsigned RESRB1              : 1;
        volatile unsigned TXRTR               : 1;
    };
    struct {
        volatile unsigned : 6;
        volatile unsigned RXRTR               : 1;
    };
} B2DLCbits @ 0xE45;

// Register: B2D0
extern volatile unsigned char           B2D0                @ 0xE46;
// bit and bitfield definitions
extern volatile bit B2D00               @ ((unsigned)&B2D0*8)+0;
extern volatile bit B2D01               @ ((unsigned)&B2D0*8)+1;
extern volatile bit B2D02               @ ((unsigned)&B2D0*8)+2;
extern volatile bit B2D03               @ ((unsigned)&B2D0*8)+3;
extern volatile bit B2D04               @ ((unsigned)&B2D0*8)+4;
extern volatile bit B2D05               @ ((unsigned)&B2D0*8)+5;
extern volatile bit B2D06               @ ((unsigned)&B2D0*8)+6;
extern volatile bit B2D07               @ ((unsigned)&B2D0*8)+7;
extern union {
    struct {
        volatile unsigned B2D00               : 1;
        volatile unsigned B2D01               : 1;
        volatile unsigned B2D02               : 1;
        volatile unsigned B2D03               : 1;
        volatile unsigned B2D04               : 1;
        volatile unsigned B2D05               : 1;
        volatile unsigned B2D06               : 1;
        volatile unsigned B2D07               : 1;
    };
} B2D0bits @ 0xE46;

// Register: B2D1
extern volatile unsigned char           B2D1                @ 0xE47;
// bit and bitfield definitions
extern volatile bit B2D10               @ ((unsigned)&B2D1*8)+0;
extern volatile bit B2D11               @ ((unsigned)&B2D1*8)+1;
extern volatile bit B2D12               @ ((unsigned)&B2D1*8)+2;
extern volatile bit B2D13               @ ((unsigned)&B2D1*8)+3;
extern volatile bit B2D14               @ ((unsigned)&B2D1*8)+4;
extern volatile bit B2D15               @ ((unsigned)&B2D1*8)+5;
extern volatile bit B2D16               @ ((unsigned)&B2D1*8)+6;
extern volatile bit B2D17               @ ((unsigned)&B2D1*8)+7;
extern union {
    struct {
        volatile unsigned B2D10               : 1;
        volatile unsigned B2D11               : 1;
        volatile unsigned B2D12               : 1;
        volatile unsigned B2D13               : 1;
        volatile unsigned B2D14               : 1;
        volatile unsigned B2D15               : 1;
        volatile unsigned B2D16               : 1;
        volatile unsigned B2D17               : 1;
    };
} B2D1bits @ 0xE47;

// Register: B2D2
extern volatile unsigned char           B2D2                @ 0xE48;
// bit and bitfield definitions
extern volatile bit B2D20               @ ((unsigned)&B2D2*8)+0;
extern volatile bit B2D21               @ ((unsigned)&B2D2*8)+1;
extern volatile bit B2D22               @ ((unsigned)&B2D2*8)+2;
extern volatile bit B2D23               @ ((unsigned)&B2D2*8)+3;
extern volatile bit B2D24               @ ((unsigned)&B2D2*8)+4;
extern volatile bit B2D25               @ ((unsigned)&B2D2*8)+5;
extern volatile bit B2D26               @ ((unsigned)&B2D2*8)+6;
extern volatile bit B2D27               @ ((unsigned)&B2D2*8)+7;
extern union {
    struct {
        volatile unsigned B2D20               : 1;
        volatile unsigned B2D21               : 1;
        volatile unsigned B2D22               : 1;
        volatile unsigned B2D23               : 1;
        volatile unsigned B2D24               : 1;
        volatile unsigned B2D25               : 1;
        volatile unsigned B2D26               : 1;
        volatile unsigned B2D27               : 1;
    };
} B2D2bits @ 0xE48;

// Register: B2D3
extern volatile unsigned char           B2D3                @ 0xE49;
// bit and bitfield definitions
extern volatile bit B2D30               @ ((unsigned)&B2D3*8)+0;
extern volatile bit B2D31               @ ((unsigned)&B2D3*8)+1;
extern volatile bit B2D32               @ ((unsigned)&B2D3*8)+2;
extern volatile bit B2D33               @ ((unsigned)&B2D3*8)+3;
extern volatile bit B2D34               @ ((unsigned)&B2D3*8)+4;
extern volatile bit B2D35               @ ((unsigned)&B2D3*8)+5;
extern volatile bit B2D36               @ ((unsigned)&B2D3*8)+6;
extern volatile bit B2D37               @ ((unsigned)&B2D3*8)+7;
extern union {
    struct {
        volatile unsigned B2D30               : 1;
        volatile unsigned B2D31               : 1;
        volatile unsigned B2D32               : 1;
        volatile unsigned B2D33               : 1;
        volatile unsigned B2D34               : 1;
        volatile unsigned B2D35               : 1;
        volatile unsigned B2D36               : 1;
        volatile unsigned B2D37               : 1;
    };
} B2D3bits @ 0xE49;

// Register: B2D4
extern volatile unsigned char           B2D4                @ 0xE4A;
// bit and bitfield definitions
extern volatile bit B2D40               @ ((unsigned)&B2D4*8)+0;
extern volatile bit B2D41               @ ((unsigned)&B2D4*8)+1;
extern volatile bit B2D42               @ ((unsigned)&B2D4*8)+2;
extern volatile bit B2D43               @ ((unsigned)&B2D4*8)+3;
extern volatile bit B2D44               @ ((unsigned)&B2D4*8)+4;
extern volatile bit B2D45               @ ((unsigned)&B2D4*8)+5;
extern volatile bit B2D46               @ ((unsigned)&B2D4*8)+6;
extern volatile bit B2D47               @ ((unsigned)&B2D4*8)+7;
extern union {
    struct {
        volatile unsigned B2D40               : 1;
        volatile unsigned B2D41               : 1;
        volatile unsigned B2D42               : 1;
        volatile unsigned B2D43               : 1;
        volatile unsigned B2D44               : 1;
        volatile unsigned B2D45               : 1;
        volatile unsigned B2D46               : 1;
        volatile unsigned B2D47               : 1;
    };
} B2D4bits @ 0xE4A;

// Register: B2D5
extern volatile unsigned char           B2D5                @ 0xE4B;
// bit and bitfield definitions
extern volatile bit B2D50               @ ((unsigned)&B2D5*8)+0;
extern volatile bit B2D51               @ ((unsigned)&B2D5*8)+1;
extern volatile bit B2D52               @ ((unsigned)&B2D5*8)+2;
extern volatile bit B2D53               @ ((unsigned)&B2D5*8)+3;
extern volatile bit B2D54               @ ((unsigned)&B2D5*8)+4;
extern volatile bit B2D55               @ ((unsigned)&B2D5*8)+5;
extern volatile bit B2D56               @ ((unsigned)&B2D5*8)+6;
extern volatile bit B2D57               @ ((unsigned)&B2D5*8)+7;
extern union {
    struct {
        volatile unsigned B2D50               : 1;
        volatile unsigned B2D51               : 1;
        volatile unsigned B2D52               : 1;
        volatile unsigned B2D53               : 1;
        volatile unsigned B2D54               : 1;
        volatile unsigned B2D55               : 1;
        volatile unsigned B2D56               : 1;
        volatile unsigned B2D57               : 1;
    };
} B2D5bits @ 0xE4B;

// Register: B2D6
extern volatile unsigned char           B2D6                @ 0xE4C;
// bit and bitfield definitions
extern volatile bit B2D60               @ ((unsigned)&B2D6*8)+0;
extern volatile bit B2D61               @ ((unsigned)&B2D6*8)+1;
extern volatile bit B2D62               @ ((unsigned)&B2D6*8)+2;
extern volatile bit B2D63               @ ((unsigned)&B2D6*8)+3;
extern volatile bit B2D64               @ ((unsigned)&B2D6*8)+4;
extern volatile bit B2D65               @ ((unsigned)&B2D6*8)+5;
extern volatile bit B2D66               @ ((unsigned)&B2D6*8)+6;
extern volatile bit B2D67               @ ((unsigned)&B2D6*8)+7;
extern union {
    struct {
        volatile unsigned B2D60               : 1;
        volatile unsigned B2D61               : 1;
        volatile unsigned B2D62               : 1;
        volatile unsigned B2D63               : 1;
        volatile unsigned B2D64               : 1;
        volatile unsigned B2D65               : 1;
        volatile unsigned B2D66               : 1;
        volatile unsigned B2D67               : 1;
    };
} B2D6bits @ 0xE4C;

// Register: B2D7
extern volatile unsigned char           B2D7                @ 0xE4D;
// bit and bitfield definitions
extern volatile bit B2D70               @ ((unsigned)&B2D7*8)+0;
extern volatile bit B2D71               @ ((unsigned)&B2D7*8)+1;
extern volatile bit B2D72               @ ((unsigned)&B2D7*8)+2;
extern volatile bit B2D73               @ ((unsigned)&B2D7*8)+3;
extern volatile bit B2D74               @ ((unsigned)&B2D7*8)+4;
extern volatile bit B2D75               @ ((unsigned)&B2D7*8)+5;
extern volatile bit B2D76               @ ((unsigned)&B2D7*8)+6;
extern volatile bit B2D77               @ ((unsigned)&B2D7*8)+7;
extern union {
    struct {
        volatile unsigned B2D70               : 1;
        volatile unsigned B2D71               : 1;
        volatile unsigned B2D72               : 1;
        volatile unsigned B2D73               : 1;
        volatile unsigned B2D74               : 1;
        volatile unsigned B2D75               : 1;
        volatile unsigned B2D76               : 1;
        volatile unsigned B2D77               : 1;
    };
} B2D7bits @ 0xE4D;

// Register: CANSTAT_RO7
extern volatile unsigned char           CANSTAT_RO7         @ 0xE4E;
// bit and bitfield definitions
//extern volatile bit EICODE0            @ ((unsigned)&CANSTAT_RO7*8)+0;
//extern volatile bit EICODE1_ICODE0     @ ((unsigned)&CANSTAT_RO7*8)+1;
//extern volatile bit EICODE2_ICODE1     @ ((unsigned)&CANSTAT_RO7*8)+2;
//extern volatile bit EICODE3_ICODE2     @ ((unsigned)&CANSTAT_RO7*8)+3;
//extern volatile bit EICODE4            @ ((unsigned)&CANSTAT_RO7*8)+4;
//extern volatile bit OPMODE0            @ ((unsigned)&CANSTAT_RO7*8)+5;
//extern volatile bit OPMODE1            @ ((unsigned)&CANSTAT_RO7*8)+6;
//extern volatile bit OPMODE2            @ ((unsigned)&CANSTAT_RO7*8)+7;
//extern volatile bit ICODE0             @ ((unsigned)&CANSTAT_RO7*8)+0;
//extern volatile bit ICODE1             @ ((unsigned)&CANSTAT_RO7*8)+1;
//extern volatile bit ICODE2             @ ((unsigned)&CANSTAT_RO7*8)+2;
//extern volatile bit ICODE3             @ ((unsigned)&CANSTAT_RO7*8)+3;
//extern volatile bit ICODE4             @ ((unsigned)&CANSTAT_RO7*8)+4;
extern union {
    struct {
        volatile unsigned EICODE0             : 1;
        volatile unsigned EICODE1_ICODE0      : 1;
        volatile unsigned EICODE2_ICODE1      : 1;
        volatile unsigned EICODE3_ICODE2      : 1;
        volatile unsigned EICODE4             : 1;
        volatile unsigned OPMODE0             : 1;
        volatile unsigned OPMODE1             : 1;
        volatile unsigned OPMODE2             : 1;
    };
    struct {
        volatile unsigned : 1;
        volatile unsigned : 1;
        volatile unsigned : 1;
        volatile unsigned : 1;
        volatile unsigned : 1;
        volatile unsigned OPMODE              : 3;
    };
    struct {
        volatile unsigned ICODE0              : 1;
        volatile unsigned ICODE1              : 1;
        volatile unsigned ICODE2              : 1;
        volatile unsigned ICODE3              : 1;
        volatile unsigned ICODE4              : 1;
    };
} CANSTAT_RO7bits @ 0xE4E;

// Register: CANCON_RO7
extern volatile unsigned char           CANCON_RO7          @ 0xE4F;
// bit and bitfield definitions
//extern volatile bit FP0                @ ((unsigned)&CANCON_RO7*8)+0;
//extern volatile bit WIN0_FP1           @ ((unsigned)&CANCON_RO7*8)+1;
//extern volatile bit WIN1_FP2           @ ((unsigned)&CANCON_RO7*8)+2;
//extern volatile bit WIN2_FP3           @ ((unsigned)&CANCON_RO7*8)+3;
//extern volatile bit ABAT               @ ((unsigned)&CANCON_RO7*8)+4;
//extern volatile bit REQOP0             @ ((unsigned)&CANCON_RO7*8)+5;
//extern volatile bit REQOP1             @ ((unsigned)&CANCON_RO7*8)+6;
//extern volatile bit REQOP2             @ ((unsigned)&CANCON_RO7*8)+7;
//extern volatile bit WIN0               @ ((unsigned)&CANCON_RO7*8)+1;
//extern volatile bit WIN1               @ ((unsigned)&CANCON_RO7*8)+2;
//extern volatile bit WIN2               @ ((unsigned)&CANCON_RO7*8)+3;
extern union {
    struct {
        volatile unsigned FP0                 : 1;
        volatile unsigned WIN0_FP1            : 1;
        volatile unsigned WIN1_FP2            : 1;
        volatile unsigned WIN2_FP3            : 1;
        volatile unsigned ABAT                : 1;
        volatile unsigned REQOP0              : 1;
        volatile unsigned REQOP1              : 1;
        volatile unsigned REQOP2              : 1;
    };
    struct {
        volatile unsigned : 1;
        volatile unsigned : 1;
        volatile unsigned : 1;
        volatile unsigned : 1;
        volatile unsigned : 1;
        volatile unsigned REQOP               : 3;
    };
    struct {
        volatile unsigned                     : 1;
        volatile unsigned WIN0                : 1;
        volatile unsigned WIN1                : 1;
        volatile unsigned WIN2                : 1;
    };
} CANCON_RO7bits @ 0xE4F;

// Register: B3CON
extern volatile unsigned char           B3CON               @ 0xE50;
// bit and bitfield definitions
//extern volatile bit FILHIT0_TXPRI0     @ ((unsigned)&B3CON*8)+0;
//extern volatile bit FILHIT1_TXPRI1     @ ((unsigned)&B3CON*8)+1;
//extern volatile bit FILHIT2_RTREN      @ ((unsigned)&B3CON*8)+2;
//extern volatile bit FILHIT3_TXREQ      @ ((unsigned)&B3CON*8)+3;
//extern volatile bit FILHIT4_TXERR      @ ((unsigned)&B3CON*8)+4;
//extern volatile bit RXRTRRO_TXLARB     @ ((unsigned)&B3CON*8)+5;
//extern volatile bit RXM1_TXABT         @ ((unsigned)&B3CON*8)+6;
//extern volatile bit RXFUL_TXBIF        @ ((unsigned)&B3CON*8)+7;
//extern volatile bit FILHIT0            @ ((unsigned)&B3CON*8)+0;
//extern volatile bit FILHIT1            @ ((unsigned)&B3CON*8)+1;
//extern volatile bit FILHIT2            @ ((unsigned)&B3CON*8)+2;
//extern volatile bit FILHIT3            @ ((unsigned)&B3CON*8)+3;
//extern volatile bit FILHIT4            @ ((unsigned)&B3CON*8)+4;
//extern volatile bit RTRRO              @ ((unsigned)&B3CON*8)+5;
//extern volatile bit RXM1               @ ((unsigned)&B3CON*8)+6;
//extern volatile bit RXFUL              @ ((unsigned)&B3CON*8)+7;
//extern volatile bit TXPRI0             @ ((unsigned)&B3CON*8)+0;
//extern volatile bit TXPRI1             @ ((unsigned)&B3CON*8)+1;
//extern volatile bit RTREN              @ ((unsigned)&B3CON*8)+2;
//extern volatile bit TXREQ              @ ((unsigned)&B3CON*8)+3;
//extern volatile bit TXERR              @ ((unsigned)&B3CON*8)+4;
//extern volatile bit TXLARB             @ ((unsigned)&B3CON*8)+5;
//extern volatile bit TXABT              @ ((unsigned)&B3CON*8)+6;
//extern volatile bit TXBIF              @ ((unsigned)&B3CON*8)+7;
//extern volatile bit RXRTRRO            @ ((unsigned)&B3CON*8)+5;
extern union {
    struct {
        volatile unsigned FILHIT0_TXPRI0      : 1;
        volatile unsigned FILHIT1_TXPRI1      : 1;
        volatile unsigned FILHIT2_RTREN       : 1;
        volatile unsigned FILHIT3_TXREQ       : 1;
        volatile unsigned FILHIT4_TXERR       : 1;
        volatile unsigned RXRTRRO_TXLARB      : 1;
        volatile unsigned RXM1_TXABT          : 1;
        volatile unsigned RXFUL_TXBIF         : 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 FILHIT0             : 1;
        volatile unsigned FILHIT1             : 1;
        volatile unsigned FILHIT2             : 1;
        volatile unsigned FILHIT3             : 1;
        volatile unsigned FILHIT4             : 1;
        volatile unsigned RTRRO               : 1;
        volatile unsigned RXM1                : 1;
        volatile unsigned RXFUL               : 1;
    };
    struct {
        volatile unsigned TXPRI0              : 1;
        volatile unsigned TXPRI1              : 1;
        volatile unsigned RTREN               : 1;
        volatile unsigned TXREQ               : 1;
        volatile unsigned TXERR               : 1;
        volatile unsigned TXLARB              : 1;
        volatile unsigned TXABT               : 1;
        volatile unsigned TXBIF               : 1;
    };
    struct {
        volatile unsigned                     : 5;
        volatile unsigned RXRTRRO             : 1;
    };
} B3CONbits @ 0xE50;

// Register: B3SIDH
extern volatile unsigned char           B3SIDH              @ 0xE51;
// bit and bitfield definitions
//extern volatile bit SID3               @ ((unsigned)&B3SIDH*8)+0;
//extern volatile bit SID4               @ ((unsigned)&B3SIDH*8)+1;
//extern volatile bit SID5               @ ((unsigned)&B3SIDH*8)+2;
//extern volatile bit SID6               @ ((unsigned)&B3SIDH*8)+3;
//extern volatile bit SID7               @ ((unsigned)&B3SIDH*8)+4;
//extern volatile bit SID8               @ ((unsigned)&B3SIDH*8)+5;
//extern volatile bit SID9               @ ((unsigned)&B3SIDH*8)+6;
//extern volatile bit SID10              @ ((unsigned)&B3SIDH*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;
    };
} B3SIDHbits @ 0xE51;

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

// Register: B3EIDH
extern volatile unsigned char           B3EIDH              @ 0xE53;
// bit and bitfield definitions
//extern volatile bit EID8               @ ((unsigned)&B3EIDH*8)+0;
//extern volatile bit EID9               @ ((unsigned)&B3EIDH*8)+1;
//extern volatile bit EID10              @ ((unsigned)&B3EIDH*8)+2;
//extern volatile bit EID11              @ ((unsigned)&B3EIDH*8)+3;
//extern volatile bit EID12              @ ((unsigned)&B3EIDH*8)+4;
//extern volatile bit EID13              @ ((unsigned)&B3EIDH*8)+5;
//extern volatile bit EID14              @ ((unsigned)&B3EIDH*8)+6;
//extern volatile bit EID15              @ ((unsigned)&B3EIDH*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;
    };
} B3EIDHbits @ 0xE53;

// Register: B3EIDL
extern volatile unsigned char           B3EIDL              @ 0xE54;
// bit and bitfield definitions
//extern volatile bit EID0               @ ((unsigned)&B3EIDL*8)+0;
//extern volatile bit EID1               @ ((unsigned)&B3EIDL*8)+1;
//extern volatile bit EID2               @ ((unsigned)&B3EIDL*8)+2;
//extern volatile bit EID3               @ ((unsigned)&B3EIDL*8)+3;
//extern volatile bit EID4               @ ((unsigned)&B3EIDL*8)+4;
//extern volatile bit EID5               @ ((unsigned)&B3EIDL*8)+5;
//extern volatile bit EID6               @ ((unsigned)&B3EIDL*8)+6;
//extern volatile bit EID7               @ ((unsigned)&B3EIDL*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;
    };
} B3EIDLbits @ 0xE54;

// Register: B3DLC
extern volatile unsigned char           B3DLC               @ 0xE55;
// bit and bitfield definitions
//extern volatile bit DLC0               @ ((unsigned)&B3DLC*8)+0;
//extern volatile bit DLC1               @ ((unsigned)&B3DLC*8)+1;
//extern volatile bit DLC2               @ ((unsigned)&B3DLC*8)+2;
//extern volatile bit DLC3               @ ((unsigned)&B3DLC*8)+3;
//extern volatile bit RB0                @ ((unsigned)&B3DLC*8)+4;
//extern volatile bit RB1                @ ((unsigned)&B3DLC*8)+5;
//extern volatile bit RXRTR_TXRTR        @ ((unsigned)&B3DLC*8)+6;
//extern volatile bit RESRB0             @ ((unsigned)&B3DLC*8)+4;
//extern volatile bit RESRB1             @ ((unsigned)&B3DLC*8)+5;
//extern volatile bit TXRTR              @ ((unsigned)&B3DLC*8)+6;
//extern volatile bit RXRTR              @ ((unsigned)&B3DLC*8)+6;
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_TXRTR         : 1;
    };
    struct {
        volatile unsigned DLC                 : 4;
        volatile unsigned : 1;
        volatile unsigned : 1;
        volatile unsigned : 1;
    };
    struct {
        volatile unsigned                     : 4;
        volatile unsigned RESRB0              : 1;
        volatile unsigned RESRB1              : 1;
        volatile unsigned TXRTR               : 1;
    };
    struct {
        volatile unsigned : 6;
        volatile unsigned RXRTR               : 1;
    };
} B3DLCbits @ 0xE55;

// Register: B3D0
extern volatile unsigned char           B3D0                @ 0xE56;
// bit and bitfield definitions
extern volatile bit B3D00               @ ((unsigned)&B3D0*8)+0;
extern volatile bit B3D01               @ ((unsigned)&B3D0*8)+1;
extern volatile bit B3D02               @ ((unsigned)&B3D0*8)+2;
extern volatile bit B3D03               @ ((unsigned)&B3D0*8)+3;
extern volatile bit B3D04               @ ((unsigned)&B3D0*8)+4;
extern volatile bit B3D05               @ ((unsigned)&B3D0*8)+5;
extern volatile bit B3D06               @ ((unsigned)&B3D0*8)+6;
extern volatile bit B3D07               @ ((unsigned)&B3D0*8)+7;
extern union {
    struct {
        volatile unsigned B3D00               : 1;
        volatile unsigned B3D01               : 1;
        volatile unsigned B3D02               : 1;
        volatile unsigned B3D03               : 1;
        volatile unsigned B3D04               : 1;
        volatile unsigned B3D05               : 1;
        volatile unsigned B3D06               : 1;
        volatile unsigned B3D07               : 1;
    };
} B3D0bits @ 0xE56;

// Register: B3D1
extern volatile unsigned char           B3D1                @ 0xE57;
// bit and bitfield definitions
extern volatile bit B3D10               @ ((unsigned)&B3D1*8)+0;
extern volatile bit B3D11               @ ((unsigned)&B3D1*8)+1;
extern volatile bit B3D12               @ ((unsigned)&B3D1*8)+2;
extern volatile bit B3D13               @ ((unsigned)&B3D1*8)+3;
extern volatile bit B3D14               @ ((unsigned)&B3D1*8)+4;
extern volatile bit B3D15               @ ((unsigned)&B3D1*8)+5;
extern volatile bit B3D16               @ ((unsigned)&B3D1*8)+6;
extern volatile bit B3D17               @ ((unsigned)&B3D1*8)+7;
extern union {
    struct {
        volatile unsigned B3D10               : 1;
        volatile unsigned B3D11               : 1;
        volatile unsigned B3D12               : 1;
        volatile unsigned B3D13               : 1;
        volatile unsigned B3D14               : 1;
        volatile unsigned B3D15               : 1;
        volatile unsigned B3D16               : 1;
        volatile unsigned B3D17               : 1;
    };
} B3D1bits @ 0xE57;

// Register: B3D2
extern volatile unsigned char           B3D2                @ 0xE58;
// bit and bitfield definitions
extern volatile bit B3D20               @ ((unsigned)&B3D2*8)+0;
extern volatile bit B3D21               @ ((unsigned)&B3D2*8)+1;
extern volatile bit B3D22               @ ((unsigned)&B3D2*8)+2;
extern volatile bit B3D23               @ ((unsigned)&B3D2*8)+3;
extern volatile bit B3D24               @ ((unsigned)&B3D2*8)+4;
extern volatile bit B3D25               @ ((unsigned)&B3D2*8)+5;
extern volatile bit B3D26               @ ((unsigned)&B3D2*8)+6;
extern volatile bit B3D27               @ ((unsigned)&B3D2*8)+7;
extern union {
    struct {
        volatile unsigned B3D20               : 1;
        volatile unsigned B3D21               : 1;
        volatile unsigned B3D22               : 1;
        volatile unsigned B3D23               : 1;
        volatile unsigned B3D24               : 1;
        volatile unsigned B3D25               : 1;
        volatile unsigned B3D26               : 1;
        volatile unsigned B3D27               : 1;
    };
} B3D2bits @ 0xE58;

// Register: B3D3
extern volatile unsigned char           B3D3                @ 0xE59;
// bit and bitfield definitions
extern volatile bit B3D30               @ ((unsigned)&B3D3*8)+0;
extern volatile bit B3D31               @ ((unsigned)&B3D3*8)+1;
extern volatile bit B3D32               @ ((unsigned)&B3D3*8)+2;
extern volatile bit B3D33               @ ((unsigned)&B3D3*8)+3;
extern volatile bit B3D34               @ ((unsigned)&B3D3*8)+4;
extern volatile bit B3D35               @ ((unsigned)&B3D3*8)+5;
extern volatile bit B3D36               @ ((unsigned)&B3D3*8)+6;
extern volatile bit B3D37               @ ((unsigned)&B3D3*8)+7;
extern union {
    struct {
        volatile unsigned B3D30               : 1;
        volatile unsigned B3D31               : 1;
        volatile unsigned B3D32               : 1;
        volatile unsigned B3D33               : 1;
        volatile unsigned B3D34               : 1;
        volatile unsigned B3D35               : 1;
        volatile unsigned B3D36               : 1;
        volatile unsigned B3D37               : 1;
    };
} B3D3bits @ 0xE59;

// Register: B3D4
extern volatile unsigned char           B3D4                @ 0xE5A;
// bit and bitfield definitions
extern volatile bit B3D40               @ ((unsigned)&B3D4*8)+0;
extern volatile bit B3D41               @ ((unsigned)&B3D4*8)+1;
extern volatile bit B3D42               @ ((unsigned)&B3D4*8)+2;
extern volatile bit B3D43               @ ((unsigned)&B3D4*8)+3;
extern volatile bit B3D44               @ ((unsigned)&B3D4*8)+4;
extern volatile bit B3D45               @ ((unsigned)&B3D4*8)+5;
extern volatile bit B3D46               @ ((unsigned)&B3D4*8)+6;
extern volatile bit B3D47               @ ((unsigned)&B3D4*8)+7;
extern union {
    struct {
        volatile unsigned B3D40               : 1;
        volatile unsigned B3D41               : 1;
        volatile unsigned B3D42               : 1;
        volatile unsigned B3D43               : 1;
        volatile unsigned B3D44               : 1;
        volatile unsigned B3D45               : 1;
        volatile unsigned B3D46               : 1;
        volatile unsigned B3D47               : 1;
    };
} B3D4bits @ 0xE5A;

// Register: B3D5
extern volatile unsigned char           B3D5                @ 0xE5B;
// bit and bitfield definitions
extern volatile bit B3D50               @ ((unsigned)&B3D5*8)+0;
extern volatile bit B3D51               @ ((unsigned)&B3D5*8)+1;
extern volatile bit B3D52               @ ((unsigned)&B3D5*8)+2;
extern volatile bit B3D53               @ ((unsigned)&B3D5*8)+3;
extern volatile bit B3D54               @ ((unsigned)&B3D5*8)+4;
extern volatile bit B3D55               @ ((unsigned)&B3D5*8)+5;
extern volatile bit B3D56               @ ((unsigned)&B3D5*8)+6;
extern volatile bit B3D57               @ ((unsigned)&B3D5*8)+7;
extern union {
    struct {
        volatile unsigned B3D50               : 1;
        volatile unsigned B3D51               : 1;
        volatile unsigned B3D52               : 1;
        volatile unsigned B3D53               : 1;
        volatile unsigned B3D54               : 1;
        volatile unsigned B3D55               : 1;
        volatile unsigned B3D56               : 1;
        volatile unsigned B3D57               : 1;
    };
} B3D5bits @ 0xE5B;

// Register: B3D6
extern volatile unsigned char           B3D6                @ 0xE5C;
// bit and bitfield definitions
extern volatile bit B3D60               @ ((unsigned)&B3D6*8)+0;
extern volatile bit B3D61               @ ((unsigned)&B3D6*8)+1;
extern volatile bit B3D62               @ ((unsigned)&B3D6*8)+2;
extern volatile bit B3D63               @ ((unsigned)&B3D6*8)+3;
extern volatile bit B3D64               @ ((unsigned)&B3D6*8)+4;
extern volatile bit B3D65               @ ((unsigned)&B3D6*8)+5;
extern volatile bit B3D66               @ ((unsigned)&B3D6*8)+6;
extern volatile bit B3D67               @ ((unsigned)&B3D6*8)+7;
extern union {
    struct {
        volatile unsigned B3D60               : 1;
        volatile unsigned B3D61               : 1;
        volatile unsigned B3D62               : 1;
        volatile unsigned B3D63               : 1;
        volatile unsigned B3D64               : 1;
        volatile unsigned B3D65               : 1;
        volatile unsigned B3D66               : 1;
        volatile unsigned B3D67               : 1;
    };
} B3D6bits @ 0xE5C;

// Register: B3D7
extern volatile unsigned char           B3D7                @ 0xE5D;
// bit and bitfield definitions
extern volatile bit B3D70               @ ((unsigned)&B3D7*8)+0;
extern volatile bit B3D71               @ ((unsigned)&B3D7*8)+1;
extern volatile bit B3D72               @ ((unsigned)&B3D7*8)+2;
extern volatile bit B3D73               @ ((unsigned)&B3D7*8)+3;
extern volatile bit B3D74               @ ((unsigned)&B3D7*8)+4;
extern volatile bit B3D75               @ ((unsigned)&B3D7*8)+5;
extern volatile bit B3D76               @ ((unsigned)&B3D7*8)+6;
extern volatile bit B3D77               @ ((unsigned)&B3D7*8)+7;
extern union {
    struct {
        volatile unsigned B3D70               : 1;
        volatile unsigned B3D71               : 1;
        volatile unsigned B3D72               : 1;
        volatile unsigned B3D73               : 1;
        volatile unsigned B3D74               : 1;
        volatile unsigned B3D75               : 1;
        volatile unsigned B3D76               : 1;
        volatile unsigned B3D77               : 1;
    };
} B3D7bits @ 0xE5D;

// Register: CANSTAT_RO6
extern volatile unsigned char           CANSTAT_RO6         @ 0xE5E;
// bit and bitfield definitions
//extern volatile bit EICODE0            @ ((unsigned)&CANSTAT_RO6*8)+0;
//extern volatile bit EICODE1_ICODE0     @ ((unsigned)&CANSTAT_RO6*8)+1;
//extern volatile bit EICODE2_ICODE1     @ ((unsigned)&CANSTAT_RO6*8)+2;
//extern volatile bit EICODE3_ICODE2     @ ((unsigned)&CANSTAT_RO6*8)+3;
//extern volatile bit EICODE4            @ ((unsigned)&CANSTAT_RO6*8)+4;
//extern volatile bit OPMODE0            @ ((unsigned)&CANSTAT_RO6*8)+5;
//extern volatile bit OPMODE1            @ ((unsigned)&CANSTAT_RO6*8)+6;
//extern volatile bit OPMODE2            @ ((unsigned)&CANSTAT_RO6*8)+7;
//extern volatile bit ICODE0             @ ((unsigned)&CANSTAT_RO6*8)+0;
//extern volatile bit ICODE1             @ ((unsigned)&CANSTAT_RO6*8)+1;
//extern volatile bit ICODE2             @ ((unsigned)&CANSTAT_RO6*8)+2;
//extern volatile bit ICODE3             @ ((unsigned)&CANSTAT_RO6*8)+3;
//extern volatile bit ICODE4             @ ((unsigned)&CANSTAT_RO6*8)+4;
extern union {
    struct {
        volatile unsigned EICODE0             : 1;
        volatile unsigned EICODE1_ICODE0      : 1;
        volatile unsigned EICODE2_ICODE1      : 1;
        volatile unsigned EICODE3_ICODE2      : 1;
        volatile unsigned EICODE4             : 1;
        volatile unsigned OPMODE0             : 1;
        volatile unsigned OPMODE1             : 1;
        volatile unsigned OPMODE2             : 1;
    };
    struct {
        volatile unsigned : 1;
        volatile unsigned : 1;
        volatile unsigned : 1;
        volatile unsigned : 1;
        volatile unsigned : 1;
        volatile unsigned OPMODE              : 3;
    };
    struct {
        volatile unsigned ICODE0              : 1;
        volatile unsigned ICODE1              : 1;
        volatile unsigned ICODE2              : 1;
        volatile unsigned ICODE3              : 1;
        volatile unsigned ICODE4              : 1;
    };
} CANSTAT_RO6bits @ 0xE5E;

// Register: CANCON_RO6
extern volatile unsigned char           CANCON_RO6          @ 0xE5F;
// bit and bitfield definitions
//extern volatile bit FP0                @ ((unsigned)&CANCON_RO6*8)+0;
//extern volatile bit WIN0_FP1           @ ((unsigned)&CANCON_RO6*8)+1;
//extern volatile bit WIN1_FP2           @ ((unsigned)&CANCON_RO6*8)+2;
//extern volatile bit WIN2_FP3           @ ((unsigned)&CANCON_RO6*8)+3;
//extern volatile bit ABAT               @ ((unsigned)&CANCON_RO6*8)+4;
//extern volatile bit REQOP0             @ ((unsigned)&CANCON_RO6*8)+5;
//extern volatile bit REQOP1             @ ((unsigned)&CANCON_RO6*8)+6;
//extern volatile bit REQOP2             @ ((unsigned)&CANCON_RO6*8)+7;
//extern volatile bit WIN0               @ ((unsigned)&CANCON_RO6*8)+1;
//extern volatile bit WIN1               @ ((unsigned)&CANCON_RO6*8)+2;
//extern volatile bit WIN2               @ ((unsigned)&CANCON_RO6*8)+3;
extern union {
    struct {
        volatile unsigned FP0                 : 1;
        volatile unsigned WIN0_FP1            : 1;
        volatile unsigned WIN1_FP2            : 1;
        volatile unsigned WIN2_FP3            : 1;
        volatile unsigned ABAT                : 1;
        volatile unsigned REQOP0              : 1;
        volatile unsigned REQOP1              : 1;
        volatile unsigned REQOP2              : 1;
    };
    struct {
        volatile unsigned : 1;
        volatile unsigned : 1;
        volatile unsigned : 1;
        volatile unsigned : 1;
        volatile unsigned : 1;
        volatile unsigned REQOP               : 3;
    };
    struct {
        volatile unsigned                     : 1;
        volatile unsigned WIN0                : 1;
        volatile unsigned WIN1                : 1;
        volatile unsigned WIN2                : 1;
    };
} CANCON_RO6bits @ 0xE5F;

// Register: B4CON
extern volatile unsigned char           B4CON               @ 0xE60;
// bit and bitfield definitions
//extern volatile bit FILHIT0_TXPRI0     @ ((unsigned)&B4CON*8)+0;
//extern volatile bit FILHIT1_TXPRI1     @ ((unsigned)&B4CON*8)+1;
//extern volatile bit FILHIT2_RTREN      @ ((unsigned)&B4CON*8)+2;
//extern volatile bit FILHIT3_TXREQ      @ ((unsigned)&B4CON*8)+3;
//extern volatile bit FILHIT4_TXERR      @ ((unsigned)&B4CON*8)+4;
//extern volatile bit RXRTRRO_TXLARB     @ ((unsigned)&B4CON*8)+5;
//extern volatile bit RXM1_TXABT         @ ((unsigned)&B4CON*8)+6;
//extern volatile bit RXFUL_TXBIF        @ ((unsigned)&B4CON*8)+7;
//extern volatile bit FILHIT0            @ ((unsigned)&B4CON*8)+0;
//extern volatile bit FILHIT1            @ ((unsigned)&B4CON*8)+1;
//extern volatile bit FILHIT2            @ ((unsigned)&B4CON*8)+2;
//extern volatile bit FILHIT3            @ ((unsigned)&B4CON*8)+3;
//extern volatile bit FILHIT4            @ ((unsigned)&B4CON*8)+4;
//extern volatile bit RTRRO              @ ((unsigned)&B4CON*8)+5;
//extern volatile bit RXM1               @ ((unsigned)&B4CON*8)+6;
//extern volatile bit RXFUL              @ ((unsigned)&B4CON*8)+7;
//extern volatile bit TXPRI0             @ ((unsigned)&B4CON*8)+0;
//extern volatile bit TXPRI1             @ ((unsigned)&B4CON*8)+1;
//extern volatile bit RTREN              @ ((unsigned)&B4CON*8)+2;
//extern volatile bit TXREQ              @ ((unsigned)&B4CON*8)+3;
//extern volatile bit TXERR              @ ((unsigned)&B4CON*8)+4;
//extern volatile bit TXLARB             @ ((unsigned)&B4CON*8)+5;
//extern volatile bit TXABT              @ ((unsigned)&B4CON*8)+6;
//extern volatile bit TXBIF              @ ((unsigned)&B4CON*8)+7;
//extern volatile bit RXRTRRO            @ ((unsigned)&B4CON*8)+5;
extern union {
    struct {
        volatile unsigned FILHIT0_TXPRI0      : 1;
        volatile unsigned FILHIT1_TXPRI1      : 1;
        volatile unsigned FILHIT2_RTREN       : 1;
        volatile unsigned FILHIT3_TXREQ       : 1;
        volatile unsigned FILHIT4_TXERR       : 1;
        volatile unsigned RXRTRRO_TXLARB      : 1;
        volatile unsigned RXM1_TXABT          : 1;
        volatile unsigned RXFUL_TXBIF         : 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 FILHIT0             : 1;
        volatile unsigned FILHIT1             : 1;
        volatile unsigned FILHIT2             : 1;
        volatile unsigned FILHIT3             : 1;
        volatile unsigned FILHIT4             : 1;
        volatile unsigned RTRRO               : 1;
        volatile unsigned RXM1                : 1;
        volatile unsigned RXFUL               : 1;
    };
    struct {
        volatile unsigned TXPRI0              : 1;
        volatile unsigned TXPRI1              : 1;
        volatile unsigned RTREN               : 1;
        volatile unsigned TXREQ               : 1;
        volatile unsigned TXERR               : 1;
        volatile unsigned TXLARB              : 1;
        volatile unsigned TXABT               : 1;
        volatile unsigned TXBIF               : 1;
    };
    struct {
        volatile unsigned                     : 5;
        volatile unsigned RXRTRRO             : 1;
    };
} B4CONbits @ 0xE60;

// Register: B4SIDH
extern volatile unsigned char           B4SIDH              @ 0xE61;
// bit and bitfield definitions
//extern volatile bit SID3               @ ((unsigned)&B4SIDH*8)+0;
//extern volatile bit SID4               @ ((unsigned)&B4SIDH*8)+1;
//extern volatile bit SID5               @ ((unsigned)&B4SIDH*8)+2;
//extern volatile bit SID6               @ ((unsigned)&B4SIDH*8)+3;
//extern volatile bit SID7               @ ((unsigned)&B4SIDH*8)+4;
//extern volatile bit SID8               @ ((unsigned)&B4SIDH*8)+5;
//extern volatile bit SID9               @ ((unsigned)&B4SIDH*8)+6;
//extern volatile bit SID10              @ ((unsigned)&B4SIDH*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;
    };
} B4SIDHbits @ 0xE61;

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

// Register: B4EIDH
extern volatile unsigned char           B4EIDH              @ 0xE63;
// bit and bitfield definitions
//extern volatile bit EID8               @ ((unsigned)&B4EIDH*8)+0;
//extern volatile bit EID9               @ ((unsigned)&B4EIDH*8)+1;
//extern volatile bit EID10              @ ((unsigned)&B4EIDH*8)+2;
//extern volatile bit EID11              @ ((unsigned)&B4EIDH*8)+3;
//extern volatile bit EID12              @ ((unsigned)&B4EIDH*8)+4;
//extern volatile bit EID13              @ ((unsigned)&B4EIDH*8)+5;
//extern volatile bit EID14              @ ((unsigned)&B4EIDH*8)+6;
//extern volatile bit EID15              @ ((unsigned)&B4EIDH*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;
    };
} B4EIDHbits @ 0xE63;

// Register: B4EIDL
extern volatile unsigned char           B4EIDL              @ 0xE64;
// bit and bitfield definitions
//extern volatile bit EID0               @ ((unsigned)&B4EIDL*8)+0;
//extern volatile bit EID1               @ ((unsigned)&B4EIDL*8)+1;
//extern volatile bit EID2               @ ((unsigned)&B4EIDL*8)+2;
//extern volatile bit EID3               @ ((unsigned)&B4EIDL*8)+3;
//extern volatile bit EID4               @ ((unsigned)&B4EIDL*8)+4;
//extern volatile bit EID5               @ ((unsigned)&B4EIDL*8)+5;
//extern volatile bit EID6               @ ((unsigned)&B4EIDL*8)+6;
//extern volatile bit EID7               @ ((unsigned)&B4EIDL*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;
    };
} B4EIDLbits @ 0xE64;

// Register: B4DLC
extern volatile unsigned char           B4DLC               @ 0xE65;
// bit and bitfield definitions
//extern volatile bit DLC0               @ ((unsigned)&B4DLC*8)+0;
//extern volatile bit DLC1               @ ((unsigned)&B4DLC*8)+1;
//extern volatile bit DLC2               @ ((unsigned)&B4DLC*8)+2;
//extern volatile bit DLC3               @ ((unsigned)&B4DLC*8)+3;
//extern volatile bit RB0                @ ((unsigned)&B4DLC*8)+4;
//extern volatile bit RB1                @ ((unsigned)&B4DLC*8)+5;
//extern volatile bit RXRTR_TXRTR        @ ((unsigned)&B4DLC*8)+6;
//extern volatile bit RESRB0             @ ((unsigned)&B4DLC*8)+4;
//extern volatile bit RESRB1             @ ((unsigned)&B4DLC*8)+5;
//extern volatile bit TXRTR              @ ((unsigned)&B4DLC*8)+6;
//extern volatile bit RXRTR              @ ((unsigned)&B4DLC*8)+6;
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_TXRTR         : 1;
    };
    struct {
        volatile unsigned DLC                 : 4;
        volatile unsigned : 1;
        volatile unsigned : 1;
        volatile unsigned : 1;
    };
    struct {
        volatile unsigned                     : 4;
        volatile unsigned RESRB0              : 1;
        volatile unsigned RESRB1              : 1;
        volatile unsigned TXRTR               : 1;
    };
    struct {
        volatile unsigned : 6;
        volatile unsigned RXRTR               : 1;
    };
} B4DLCbits @ 0xE65;

// Register: B4D0
extern volatile unsigned char           B4D0                @ 0xE66;
// bit and bitfield definitions
extern volatile bit B4D00               @ ((unsigned)&B4D0*8)+0;
extern volatile bit B4D01               @ ((unsigned)&B4D0*8)+1;
extern volatile bit B4D02               @ ((unsigned)&B4D0*8)+2;
extern volatile bit B4D03               @ ((unsigned)&B4D0*8)+3;
extern volatile bit B4D04               @ ((unsigned)&B4D0*8)+4;
extern volatile bit B4D05               @ ((unsigned)&B4D0*8)+5;
extern volatile bit B4D06               @ ((unsigned)&B4D0*8)+6;
extern volatile bit B4D07               @ ((unsigned)&B4D0*8)+7;
extern union {
    struct {
        volatile unsigned B4D00               : 1;
        volatile unsigned B4D01               : 1;
        volatile unsigned B4D02               : 1;
        volatile unsigned B4D03               : 1;
        volatile unsigned B4D04               : 1;
        volatile unsigned B4D05               : 1;
        volatile unsigned B4D06               : 1;
        volatile unsigned B4D07               : 1;
    };
} B4D0bits @ 0xE66;

// Register: B4D1
extern volatile unsigned char           B4D1                @ 0xE67;
// bit and bitfield definitions
extern volatile bit B4D10               @ ((unsigned)&B4D1*8)+0;
extern volatile bit B4D11               @ ((unsigned)&B4D1*8)+1;
extern volatile bit B4D12               @ ((unsigned)&B4D1*8)+2;
extern volatile bit B4D13               @ ((unsigned)&B4D1*8)+3;
extern volatile bit B4D14               @ ((unsigned)&B4D1*8)+4;
extern volatile bit B4D15               @ ((unsigned)&B4D1*8)+5;
extern volatile bit B4D16               @ ((unsigned)&B4D1*8)+6;
extern volatile bit B4D17               @ ((unsigned)&B4D1*8)+7;
extern union {
    struct {
        volatile unsigned B4D10               : 1;
        volatile unsigned B4D11               : 1;
        volatile unsigned B4D12               : 1;
        volatile unsigned B4D13               : 1;
        volatile unsigned B4D14               : 1;
        volatile unsigned B4D15               : 1;
        volatile unsigned B4D16               : 1;
        volatile unsigned B4D17               : 1;
    };
} B4D1bits @ 0xE67;

// Register: B4D2
extern volatile unsigned char           B4D2                @ 0xE68;
// bit and bitfield definitions
extern volatile bit B4D20               @ ((unsigned)&B4D2*8)+0;
extern volatile bit B4D21               @ ((unsigned)&B4D2*8)+1;
extern volatile bit B4D22               @ ((unsigned)&B4D2*8)+2;
extern volatile bit B4D23               @ ((unsigned)&B4D2*8)+3;
extern volatile bit B4D24               @ ((unsigned)&B4D2*8)+4;
extern volatile bit B4D25               @ ((unsigned)&B4D2*8)+5;
extern volatile bit B4D26               @ ((unsigned)&B4D2*8)+6;
extern volatile bit B4D27               @ ((unsigned)&B4D2*8)+7;
extern union {
    struct {
        volatile unsigned B4D20               : 1;
        volatile unsigned B4D21               : 1;
        volatile unsigned B4D22               : 1;
        volatile unsigned B4D23               : 1;
        volatile unsigned B4D24               : 1;
        volatile unsigned B4D25               : 1;
        volatile unsigned B4D26               : 1;
        volatile unsigned B4D27               : 1;
    };
} B4D2bits @ 0xE68;

// Register: B4D3
extern volatile unsigned char           B4D3                @ 0xE69;
// bit and bitfield definitions
extern volatile bit B4D30               @ ((unsigned)&B4D3*8)+0;
extern volatile bit B4D31               @ ((unsigned)&B4D3*8)+1;
extern volatile bit B4D32               @ ((unsigned)&B4D3*8)+2;
extern volatile bit B4D33               @ ((unsigned)&B4D3*8)+3;
extern volatile bit B4D34               @ ((unsigned)&B4D3*8)+4;
extern volatile bit B4D35               @ ((unsigned)&B4D3*8)+5;
extern volatile bit B4D36               @ ((unsigned)&B4D3*8)+6;
extern volatile bit B4D37               @ ((unsigned)&B4D3*8)+7;
extern union {
    struct {
        volatile unsigned B4D30               : 1;
        volatile unsigned B4D31               : 1;
        volatile unsigned B4D32               : 1;
        volatile unsigned B4D33               : 1;
        volatile unsigned B4D34               : 1;
        volatile unsigned B4D35               : 1;
        volatile unsigned B4D36               : 1;
        volatile unsigned B4D37               : 1;
    };
} B4D3bits @ 0xE69;

// Register: B4D4
extern volatile unsigned char           B4D4                @ 0xE6A;
// bit and bitfield definitions
extern volatile bit B4D40               @ ((unsigned)&B4D4*8)+0;
extern volatile bit B4D41               @ ((unsigned)&B4D4*8)+1;
extern volatile bit B4D42               @ ((unsigned)&B4D4*8)+2;
extern volatile bit B4D43               @ ((unsigned)&B4D4*8)+3;
extern volatile bit B4D44               @ ((unsigned)&B4D4*8)+4;
extern volatile bit B4D45               @ ((unsigned)&B4D4*8)+5;
extern volatile bit B4D46               @ ((unsigned)&B4D4*8)+6;
extern volatile bit B4D47               @ ((unsigned)&B4D4*8)+7;
extern union {
    struct {
        volatile unsigned B4D40               : 1;
        volatile unsigned B4D41               : 1;
        volatile unsigned B4D42               : 1;
        volatile unsigned B4D43               : 1;
        volatile unsigned B4D44               : 1;
        volatile unsigned B4D45               : 1;
        volatile unsigned B4D46               : 1;
        volatile unsigned B4D47               : 1;
    };
} B4D4bits @ 0xE6A;

// Register: B4D5
extern volatile unsigned char           B4D5                @ 0xE6B;
// bit and bitfield definitions
extern volatile bit B4D50               @ ((unsigned)&B4D5*8)+0;
extern volatile bit B4D51               @ ((unsigned)&B4D5*8)+1;
extern volatile bit B4D52               @ ((unsigned)&B4D5*8)+2;
extern volatile bit B4D53               @ ((unsigned)&B4D5*8)+3;
extern volatile bit B4D54               @ ((unsigned)&B4D5*8)+4;
extern volatile bit B4D55               @ ((unsigned)&B4D5*8)+5;
extern volatile bit B4D56               @ ((unsigned)&B4D5*8)+6;
extern volatile bit B4D57               @ ((unsigned)&B4D5*8)+7;
extern union {
    struct {
        volatile unsigned B4D50               : 1;
        volatile unsigned B4D51               : 1;
        volatile unsigned B4D52               : 1;
        volatile unsigned B4D53               : 1;
        volatile unsigned B4D54               : 1;
        volatile unsigned B4D55               : 1;
        volatile unsigned B4D56               : 1;
        volatile unsigned B4D57               : 1;
    };
} B4D5bits @ 0xE6B;

// Register: B4D6
extern volatile unsigned char           B4D6                @ 0xE6C;
// bit and bitfield definitions
extern volatile bit B4D60               @ ((unsigned)&B4D6*8)+0;
extern volatile bit B4D61               @ ((unsigned)&B4D6*8)+1;
extern volatile bit B4D62               @ ((unsigned)&B4D6*8)+2;
extern volatile bit B4D63               @ ((unsigned)&B4D6*8)+3;
extern volatile bit B4D64               @ ((unsigned)&B4D6*8)+4;
extern volatile bit B4D65               @ ((unsigned)&B4D6*8)+5;
extern volatile bit B4D66               @ ((unsigned)&B4D6*8)+6;
extern volatile bit B4D67               @ ((unsigned)&B4D6*8)+7;
extern union {
    struct {
        volatile unsigned B4D60               : 1;
        volatile unsigned B4D61               : 1;
        volatile unsigned B4D62               : 1;
        volatile unsigned B4D63               : 1;
        volatile unsigned B4D64               : 1;
        volatile unsigned B4D65               : 1;
        volatile unsigned B4D66               : 1;
        volatile unsigned B4D67               : 1;
    };
} B4D6bits @ 0xE6C;

// Register: B4D7
extern volatile unsigned char           B4D7                @ 0xE6D;
// bit and bitfield definitions
extern volatile bit B4D70               @ ((unsigned)&B4D7*8)+0;
extern volatile bit B4D71               @ ((unsigned)&B4D7*8)+1;
extern volatile bit B4D72               @ ((unsigned)&B4D7*8)+2;
extern volatile bit B4D73               @ ((unsigned)&B4D7*8)+3;
extern volatile bit B4D74               @ ((unsigned)&B4D7*8)+4;
extern volatile bit B4D75               @ ((unsigned)&B4D7*8)+5;
extern volatile bit B4D76               @ ((unsigned)&B4D7*8)+6;
extern volatile bit B4D77               @ ((unsigned)&B4D7*8)+7;
extern volatile bit B46D77              @ ((unsigned)&B4D7*8)+7;
extern union {
    struct {
        volatile unsigned B4D70               : 1;
        volatile unsigned B4D71               : 1;
        volatile unsigned B4D72               : 1;
        volatile unsigned B4D73               : 1;
        volatile unsigned B4D74               : 1;
        volatile unsigned B4D75               : 1;
        volatile unsigned B4D76               : 1;
        volatile unsigned B4D77               : 1;
    };
    struct {
        volatile unsigned                     : 7;
        volatile unsigned B46D77              : 1;
    };
} B4D7bits @ 0xE6D;

// Register: CANSTAT_RO5
extern volatile unsigned char           CANSTAT_RO5         @ 0xE6E;
// bit and bitfield definitions
//extern volatile bit EICODE0            @ ((unsigned)&CANSTAT_RO5*8)+0;
//extern volatile bit EICODE1_ICODE0     @ ((unsigned)&CANSTAT_RO5*8)+1;
//extern volatile bit EICODE2_ICODE1     @ ((unsigned)&CANSTAT_RO5*8)+2;
//extern volatile bit EICODE3_ICODE2     @ ((unsigned)&CANSTAT_RO5*8)+3;
//extern volatile bit EICODE4            @ ((unsigned)&CANSTAT_RO5*8)+4;
//extern volatile bit OPMODE0            @ ((unsigned)&CANSTAT_RO5*8)+5;
//extern volatile bit OPMODE1            @ ((unsigned)&CANSTAT_RO5*8)+6;
//extern volatile bit OPMODE2            @ ((unsigned)&CANSTAT_RO5*8)+7;
//extern volatile bit ICODE0             @ ((unsigned)&CANSTAT_RO5*8)+0;
//extern volatile bit ICODE1             @ ((unsigned)&CANSTAT_RO5*8)+1;
//extern volatile bit ICODE2             @ ((unsigned)&CANSTAT_RO5*8)+2;
//extern volatile bit ICODE3             @ ((unsigned)&CANSTAT_RO5*8)+3;
//extern volatile bit ICODE4             @ ((unsigned)&CANSTAT_RO5*8)+4;
extern union {
    struct {
        volatile unsigned EICODE0             : 1;
        volatile unsigned EICODE1_ICODE0      : 1;
        volatile unsigned EICODE2_ICODE1      : 1;
        volatile unsigned EICODE3_ICODE2      : 1;
        volatile unsigned EICODE4             : 1;
        volatile unsigned OPMODE0             : 1;
        volatile unsigned OPMODE1             : 1;
        volatile unsigned OPMODE2             : 1;
    };
    struct {
        volatile unsigned : 1;
        volatile unsigned : 1;
        volatile unsigned : 1;
        volatile unsigned : 1;
        volatile unsigned : 1;
        volatile unsigned OPMODE              : 3;
    };
    struct {
        volatile unsigned ICODE0              : 1;
        volatile unsigned ICODE1              : 1;
        volatile unsigned ICODE2              : 1;
        volatile unsigned ICODE3              : 1;
        volatile unsigned ICODE4              : 1;
    };
} CANSTAT_RO5bits @ 0xE6E;

// Register: CANCON_RO5
extern volatile unsigned char           CANCON_RO5          @ 0xE6F;
// bit and bitfield definitions
//extern volatile bit FP0                @ ((unsigned)&CANCON_RO5*8)+0;
//extern volatile bit WIN0_FP1           @ ((unsigned)&CANCON_RO5*8)+1;
//extern volatile bit WIN1_FP2           @ ((unsigned)&CANCON_RO5*8)+2;
//extern volatile bit WIN2_FP3           @ ((unsigned)&CANCON_RO5*8)+3;
//extern volatile bit ABAT               @ ((unsigned)&CANCON_RO5*8)+4;
//extern volatile bit REQOP0             @ ((unsigned)&CANCON_RO5*8)+5;
//extern volatile bit REQOP1             @ ((unsigned)&CANCON_RO5*8)+6;
//extern volatile bit REQOP2             @ ((unsigned)&CANCON_RO5*8)+7;
//extern volatile bit WIN0               @ ((unsigned)&CANCON_RO5*8)+1;
//extern volatile bit WIN1               @ ((unsigned)&CANCON_RO5*8)+2;
//extern volatile bit WIN2               @ ((unsigned)&CANCON_RO5*8)+3;
extern union {
    struct {
        volatile unsigned FP0                 : 1;
        volatile unsigned WIN0_FP1            : 1;
        volatile unsigned WIN1_FP2            : 1;
        volatile unsigned WIN2_FP3            : 1;
        volatile unsigned ABAT                : 1;
        volatile unsigned REQOP0              : 1;
        volatile unsigned REQOP1              : 1;
        volatile unsigned REQOP2              : 1;
    };
    struct {
        volatile unsigned : 1;
        volatile unsigned : 1;
        volatile unsigned : 1;
        volatile unsigned : 1;
        volatile unsigned : 1;
        volatile unsigned REQOP               : 3;
    };
    struct {
        volatile unsigned                     : 1;
        volatile unsigned WIN0                : 1;
        volatile unsigned WIN1                : 1;
        volatile unsigned WIN2                : 1;
    };
} CANCON_RO5bits @ 0xE6F;

// Register: B5CON
extern volatile unsigned char           B5CON               @ 0xE70;
// bit and bitfield definitions
//extern volatile bit FILHIT0_TXPRI0     @ ((unsigned)&B5CON*8)+0;
//extern volatile bit FILHIT1_TXPRI1     @ ((unsigned)&B5CON*8)+1;
//extern volatile bit FILHIT2_RTREN      @ ((unsigned)&B5CON*8)+2;
//extern volatile bit FILHIT3_TXREQ      @ ((unsigned)&B5CON*8)+3;
//extern volatile bit FILHIT4_TXERR      @ ((unsigned)&B5CON*8)+4;
//extern volatile bit RXRTRRO_TXLARB     @ ((unsigned)&B5CON*8)+5;
//extern volatile bit RXM1_TXABT         @ ((unsigned)&B5CON*8)+6;
//extern volatile bit RXFUL_TXBIF        @ ((unsigned)&B5CON*8)+7;
//extern volatile bit FILHIT0            @ ((unsigned)&B5CON*8)+0;
//extern volatile bit FILHIT1            @ ((unsigned)&B5CON*8)+1;
//extern volatile bit FILHIT2            @ ((unsigned)&B5CON*8)+2;
//extern volatile bit FILHIT3            @ ((unsigned)&B5CON*8)+3;
//extern volatile bit FILHIT4            @ ((unsigned)&B5CON*8)+4;
//extern volatile bit RTRRO              @ ((unsigned)&B5CON*8)+5;
//extern volatile bit RXM1               @ ((unsigned)&B5CON*8)+6;
//extern volatile bit RXFUL              @ ((unsigned)&B5CON*8)+7;
//extern volatile bit TXPRI0             @ ((unsigned)&B5CON*8)+0;
//extern volatile bit TXPRI1             @ ((unsigned)&B5CON*8)+1;
//extern volatile bit RTREN              @ ((unsigned)&B5CON*8)+2;
//extern volatile bit TXREQ              @ ((unsigned)&B5CON*8)+3;
//extern volatile bit TXERR              @ ((unsigned)&B5CON*8)+4;
//extern volatile bit TXLARB             @ ((unsigned)&B5CON*8)+5;
//extern volatile bit TXABT              @ ((unsigned)&B5CON*8)+6;
//extern volatile bit TXBIF              @ ((unsigned)&B5CON*8)+7;
//extern volatile bit RXRTRRO            @ ((unsigned)&B5CON*8)+5;
extern union {
    struct {
        volatile unsigned FILHIT0_TXPRI0      : 1;
        volatile unsigned FILHIT1_TXPRI1      : 1;
        volatile unsigned FILHIT2_RTREN       : 1;
        volatile unsigned FILHIT3_TXREQ       : 1;
        volatile unsigned FILHIT4_TXERR       : 1;
        volatile unsigned RXRTRRO_TXLARB      : 1;
        volatile unsigned RXM1_TXABT          : 1;
        volatile unsigned RXFUL_TXBIF         : 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 FILHIT0             : 1;
        volatile unsigned FILHIT1             : 1;
        volatile unsigned FILHIT2             : 1;
        volatile unsigned FILHIT3             : 1;
        volatile unsigned FILHIT4             : 1;
        volatile unsigned RTRRO               : 1;
        volatile unsigned RXM1                : 1;
        volatile unsigned RXFUL               : 1;
    };
    struct {
        volatile unsigned TXPRI0              : 1;
        volatile unsigned TXPRI1              : 1;
        volatile unsigned RTREN               : 1;
        volatile unsigned TXREQ               : 1;
        volatile unsigned TXERR               : 1;
        volatile unsigned TXLARB              : 1;
        volatile unsigned TXABT               : 1;
        volatile unsigned TXBIF               : 1;
    };
    struct {
        volatile unsigned                     : 5;
        volatile unsigned RXRTRRO             : 1;
    };
} B5CONbits @ 0xE70;

// Register: B5SIDH
extern volatile unsigned char           B5SIDH              @ 0xE71;
// bit and bitfield definitions
//extern volatile bit SID3               @ ((unsigned)&B5SIDH*8)+0;
//extern volatile bit SID4               @ ((unsigned)&B5SIDH*8)+1;
//extern volatile bit SID5               @ ((unsigned)&B5SIDH*8)+2;
//extern volatile bit SID6               @ ((unsigned)&B5SIDH*8)+3;
//extern volatile bit SID7               @ ((unsigned)&B5SIDH*8)+4;
//extern volatile bit SID8               @ ((unsigned)&B5SIDH*8)+5;
//extern volatile bit SID9               @ ((unsigned)&B5SIDH*8)+6;
//extern volatile bit SID10              @ ((unsigned)&B5SIDH*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;
    };
} B5SIDHbits @ 0xE71;

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

// Register: B5EIDH
extern volatile unsigned char           B5EIDH              @ 0xE73;
// bit and bitfield definitions
//extern volatile bit EID8               @ ((unsigned)&B5EIDH*8)+0;
//extern volatile bit EID9               @ ((unsigned)&B5EIDH*8)+1;
//extern volatile bit EID10              @ ((unsigned)&B5EIDH*8)+2;
//extern volatile bit EID11              @ ((unsigned)&B5EIDH*8)+3;
//extern volatile bit EID12              @ ((unsigned)&B5EIDH*8)+4;
//extern volatile bit EID13              @ ((unsigned)&B5EIDH*8)+5;
//extern volatile bit EID14              @ ((unsigned)&B5EIDH*8)+6;
//extern volatile bit EID15              @ ((unsigned)&B5EIDH*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;
    };
} B5EIDHbits @ 0xE73;

// Register: B5EIDL
extern volatile unsigned char           B5EIDL              @ 0xE74;
// bit and bitfield definitions
//extern volatile bit EID0               @ ((unsigned)&B5EIDL*8)+0;
//extern volatile bit EID1               @ ((unsigned)&B5EIDL*8)+1;
//extern volatile bit EID2               @ ((unsigned)&B5EIDL*8)+2;
//extern volatile bit EID3               @ ((unsigned)&B5EIDL*8)+3;
//extern volatile bit EID4               @ ((unsigned)&B5EIDL*8)+4;
//extern volatile bit EID5               @ ((unsigned)&B5EIDL*8)+5;
//extern volatile bit EID6               @ ((unsigned)&B5EIDL*8)+6;
//extern volatile bit EID7               @ ((unsigned)&B5EIDL*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;
    };
} B5EIDLbits @ 0xE74;

// Register: B5DLC
extern volatile unsigned char           B5DLC               @ 0xE75;
// bit and bitfield definitions
//extern volatile bit DLC0               @ ((unsigned)&B5DLC*8)+0;
//extern volatile bit DLC1               @ ((unsigned)&B5DLC*8)+1;
//extern volatile bit DLC2               @ ((unsigned)&B5DLC*8)+2;
//extern volatile bit DLC3               @ ((unsigned)&B5DLC*8)+3;
//extern volatile bit RB0                @ ((unsigned)&B5DLC*8)+4;
//extern volatile bit RB1                @ ((unsigned)&B5DLC*8)+5;
//extern volatile bit RXRTR_TXRTR        @ ((unsigned)&B5DLC*8)+6;
//extern volatile bit RESRB0             @ ((unsigned)&B5DLC*8)+4;
//extern volatile bit RESRB1             @ ((unsigned)&B5DLC*8)+5;
//extern volatile bit RXRTR              @ ((unsigned)&B5DLC*8)+6;
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_TXRTR         : 1;
    };
    struct {
        volatile unsigned DLC                 : 4;
        volatile unsigned : 1;
        volatile unsigned : 1;
        volatile unsigned : 1;
    };
    struct {
        volatile unsigned                     : 4;
        volatile unsigned RESRB0              : 1;
        volatile unsigned RESRB1              : 1;
    };
    struct {
        volatile unsigned : 6;
        volatile unsigned RXRTR               : 1;
    };
} B5DLCbits @ 0xE75;

// Register: B5D0
extern volatile unsigned char           B5D0                @ 0xE76;
// bit and bitfield definitions
extern volatile bit B5D00               @ ((unsigned)&B5D0*8)+0;
extern volatile bit B5D01               @ ((unsigned)&B5D0*8)+1;
extern volatile bit B5D02               @ ((unsigned)&B5D0*8)+2;
extern volatile bit B5D03               @ ((unsigned)&B5D0*8)+3;
extern volatile bit B5D04               @ ((unsigned)&B5D0*8)+4;
extern volatile bit B5D05               @ ((unsigned)&B5D0*8)+5;
extern volatile bit B5D06               @ ((unsigned)&B5D0*8)+6;
extern volatile bit B5D07               @ ((unsigned)&B5D0*8)+7;
extern volatile bit B57D07              @ ((unsigned)&B5D0*8)+7;
extern union {
    struct {
        volatile unsigned B5D00               : 1;
        volatile unsigned B5D01               : 1;
        volatile unsigned B5D02               : 1;
        volatile unsigned B5D03               : 1;
        volatile unsigned B5D04               : 1;
        volatile unsigned B5D05               : 1;
        volatile unsigned B5D06               : 1;
        volatile unsigned B5D07               : 1;
    };
    struct {
        volatile unsigned                     : 7;
        volatile unsigned B57D07              : 1;
    };
} B5D0bits @ 0xE76;

// Register: B5D1
extern volatile unsigned char           B5D1                @ 0xE77;
// bit and bitfield definitions
extern volatile bit B5D10               @ ((unsigned)&B5D1*8)+0;
extern volatile bit B5D11               @ ((unsigned)&B5D1*8)+1;
extern volatile bit B5D12               @ ((unsigned)&B5D1*8)+2;
extern volatile bit B5D13               @ ((unsigned)&B5D1*8)+3;
extern volatile bit B5D14               @ ((unsigned)&B5D1*8)+4;
extern volatile bit B5D15               @ ((unsigned)&B5D1*8)+5;
extern volatile bit B5D16               @ ((unsigned)&B5D1*8)+6;
extern volatile bit B5D17               @ ((unsigned)&B5D1*8)+7;
extern union {
    struct {
        volatile unsigned B5D10               : 1;
        volatile unsigned B5D11               : 1;
        volatile unsigned B5D12               : 1;
        volatile unsigned B5D13               : 1;
        volatile unsigned B5D14               : 1;
        volatile unsigned B5D15               : 1;
        volatile unsigned B5D16               : 1;
        volatile unsigned B5D17               : 1;
    };
} B5D1bits @ 0xE77;

// Register: B5D2
extern volatile unsigned char           B5D2                @ 0xE78;
// bit and bitfield definitions
extern volatile bit B5D20               @ ((unsigned)&B5D2*8)+0;
extern volatile bit B5D21               @ ((unsigned)&B5D2*8)+1;
extern volatile bit B5D22               @ ((unsigned)&B5D2*8)+2;
extern volatile bit B5D23               @ ((unsigned)&B5D2*8)+3;
extern volatile bit B5D24               @ ((unsigned)&B5D2*8)+4;
extern volatile bit B5D25               @ ((unsigned)&B5D2*8)+5;
extern volatile bit B5D26               @ ((unsigned)&B5D2*8)+6;
extern volatile bit B5D27               @ ((unsigned)&B5D2*8)+7;
extern volatile bit B57D23              @ ((unsigned)&B5D2*8)+3;
extern union {
    struct {
        volatile unsigned B5D20               : 1;
        volatile unsigned B5D21               : 1;
        volatile unsigned B5D22               : 1;
        volatile unsigned B5D23               : 1;
        volatile unsigned B5D24               : 1;
        volatile unsigned B5D25               : 1;
        volatile unsigned B5D26               : 1;
        volatile unsigned B5D27               : 1;
    };
    struct {
        volatile unsigned                     : 3;
        volatile unsigned B57D23              : 1;
    };
} B5D2bits @ 0xE78;

// Register: B5D3
extern volatile unsigned char           B5D3                @ 0xE79;
// bit and bitfield definitions
extern volatile bit B5D30               @ ((unsigned)&B5D3*8)+0;
extern volatile bit B5D31               @ ((unsigned)&B5D3*8)+1;
extern volatile bit B5D32               @ ((unsigned)&B5D3*8)+2;
extern volatile bit B5D33               @ ((unsigned)&B5D3*8)+3;
extern volatile bit B5D34               @ ((unsigned)&B5D3*8)+4;
extern volatile bit B5D35               @ ((unsigned)&B5D3*8)+5;
extern volatile bit B5D36               @ ((unsigned)&B5D3*8)+6;
extern volatile bit B5D37               @ ((unsigned)&B5D3*8)+7;
extern union {
    struct {
        volatile unsigned B5D30               : 1;
        volatile unsigned B5D31               : 1;
        volatile unsigned B5D32               : 1;
        volatile unsigned B5D33               : 1;
        volatile unsigned B5D34               : 1;
        volatile unsigned B5D35               : 1;
        volatile unsigned B5D36               : 1;
        volatile unsigned B5D37               : 1;
    };
} B5D3bits @ 0xE79;

// Register: B5D4
extern volatile unsigned char           B5D4                @ 0xE7A;
// bit and bitfield definitions
extern volatile bit B5D40               @ ((unsigned)&B5D4*8)+0;
extern volatile bit B5D41               @ ((unsigned)&B5D4*8)+1;
extern volatile bit B5D42               @ ((unsigned)&B5D4*8)+2;
extern volatile bit B5D43               @ ((unsigned)&B5D4*8)+3;
extern volatile bit B5D44               @ ((unsigned)&B5D4*8)+4;
extern volatile bit B5D45               @ ((unsigned)&B5D4*8)+5;
extern volatile bit B5D46               @ ((unsigned)&B5D4*8)+6;
extern volatile bit B5D47               @ ((unsigned)&B5D4*8)+7;
extern union {
    struct {
        volatile unsigned B5D40               : 1;
        volatile unsigned B5D41               : 1;
        volatile unsigned B5D42               : 1;
        volatile unsigned B5D43               : 1;
        volatile unsigned B5D44               : 1;
        volatile unsigned B5D45               : 1;
        volatile unsigned B5D46               : 1;
        volatile unsigned B5D47               : 1;
    };
} B5D4bits @ 0xE7A;

// Register: B5D5
extern volatile unsigned char           B5D5                @ 0xE7B;
// bit and bitfield definitions
extern volatile bit B5D50               @ ((unsigned)&B5D5*8)+0;
extern volatile bit B5D51               @ ((unsigned)&B5D5*8)+1;
extern volatile bit B5D52               @ ((unsigned)&B5D5*8)+2;
extern volatile bit B5D53               @ ((unsigned)&B5D5*8)+3;
extern volatile bit B5D54               @ ((unsigned)&B5D5*8)+4;
extern volatile bit B5D55               @ ((unsigned)&B5D5*8)+5;
extern volatile bit B5D56               @ ((unsigned)&B5D5*8)+6;
extern volatile bit B5D57               @ ((unsigned)&B5D5*8)+7;
extern union {
    struct {
        volatile unsigned B5D50               : 1;
        volatile unsigned B5D51               : 1;
        volatile unsigned B5D52               : 1;
        volatile unsigned B5D53               : 1;
        volatile unsigned B5D54               : 1;
        volatile unsigned B5D55               : 1;
        volatile unsigned B5D56               : 1;
        volatile unsigned B5D57               : 1;
    };
} B5D5bits @ 0xE7B;

// Register: B5D6
extern volatile unsigned char           B5D6                @ 0xE7C;
// bit and bitfield definitions
extern volatile bit B5D60               @ ((unsigned)&B5D6*8)+0;
extern volatile bit B5D61               @ ((unsigned)&B5D6*8)+1;
extern volatile bit B5D62               @ ((unsigned)&B5D6*8)+2;
extern volatile bit B5D63               @ ((unsigned)&B5D6*8)+3;
extern volatile bit B5D64               @ ((unsigned)&B5D6*8)+4;
extern volatile bit B5D65               @ ((unsigned)&B5D6*8)+5;
extern volatile bit B5D66               @ ((unsigned)&B5D6*8)+6;
extern volatile bit B5D67               @ ((unsigned)&B5D6*8)+7;
extern union {
    struct {
        volatile unsigned B5D60               : 1;
        volatile unsigned B5D61               : 1;
        volatile unsigned B5D62               : 1;
        volatile unsigned B5D63               : 1;
        volatile unsigned B5D64               : 1;
        volatile unsigned B5D65               : 1;
        volatile unsigned B5D66               : 1;
        volatile unsigned B5D67               : 1;
    };
} B5D6bits @ 0xE7C;

// Register: B5D7
extern volatile unsigned char           B5D7                @ 0xE7D;
// bit and bitfield definitions
extern volatile bit B5D70               @ ((unsigned)&B5D7*8)+0;
extern volatile bit B5D71               @ ((unsigned)&B5D7*8)+1;
extern volatile bit B5D72               @ ((unsigned)&B5D7*8)+2;
extern volatile bit B5D73               @ ((unsigned)&B5D7*8)+3;
extern volatile bit B5D74               @ ((unsigned)&B5D7*8)+4;
extern volatile bit B5D75               @ ((unsigned)&B5D7*8)+5;
extern volatile bit B5D76               @ ((unsigned)&B5D7*8)+6;
extern volatile bit B5D77               @ ((unsigned)&B5D7*8)+7;
extern union {
    struct {
        volatile unsigned B5D70               : 1;
        volatile unsigned B5D71               : 1;
        volatile unsigned B5D72               : 1;
        volatile unsigned B5D73               : 1;
        volatile unsigned B5D74               : 1;
        volatile unsigned B5D75               : 1;
        volatile unsigned B5D76               : 1;
        volatile unsigned B5D77               : 1;
    };
} B5D7bits @ 0xE7D;

// Register: CANSTAT_RO4
extern volatile unsigned char           CANSTAT_RO4         @ 0xE7E;
// bit and bitfield definitions
//extern volatile bit EICODE0            @ ((unsigned)&CANSTAT_RO4*8)+0;
//extern volatile bit EICODE1_ICODE0     @ ((unsigned)&CANSTAT_RO4*8)+1;
//extern volatile bit EICODE2_ICODE1     @ ((unsigned)&CANSTAT_RO4*8)+2;
//extern volatile bit EICODE3_ICODE2     @ ((unsigned)&CANSTAT_RO4*8)+3;
//extern volatile bit EICODE4            @ ((unsigned)&CANSTAT_RO4*8)+4;
//extern volatile bit OPMODE0            @ ((unsigned)&CANSTAT_RO4*8)+5;
//extern volatile bit OPMODE1            @ ((unsigned)&CANSTAT_RO4*8)+6;
//extern volatile bit OPMODE2            @ ((unsigned)&CANSTAT_RO4*8)+7;
//extern volatile bit ICODE0             @ ((unsigned)&CANSTAT_RO4*8)+0;
//extern volatile bit ICODE1             @ ((unsigned)&CANSTAT_RO4*8)+1;
//extern volatile bit ICODE2             @ ((unsigned)&CANSTAT_RO4*8)+2;
//extern volatile bit ICODE3             @ ((unsigned)&CANSTAT_RO4*8)+3;
//extern volatile bit ICODE4             @ ((unsigned)&CANSTAT_RO4*8)+4;
extern union {
    struct {
        volatile unsigned EICODE0             : 1;
        volatile unsigned EICODE1_ICODE0      : 1;
        volatile unsigned EICODE2_ICODE1      : 1;
        volatile unsigned EICODE3_ICODE2      : 1;
        volatile unsigned EICODE4             : 1;
        volatile unsigned OPMODE0             : 1;
        volatile unsigned OPMODE1             : 1;
        volatile unsigned OPMODE2             : 1;
    };
    struct {
        volatile unsigned : 1;
        volatile unsigned : 1;
        volatile unsigned : 1;
        volatile unsigned : 1;
        volatile unsigned : 1;
        volatile unsigned OPMODE              : 3;
    };
    struct {
        volatile unsigned ICODE0              : 1;
        volatile unsigned ICODE1              : 1;
        volatile unsigned ICODE2              : 1;
        volatile unsigned ICODE3              : 1;
        volatile unsigned ICODE4              : 1;
    };
} CANSTAT_RO4bits @ 0xE7E;

// Register: CANCON_RO4
extern volatile unsigned char           CANCON_RO4          @ 0xE7F;
// bit and bitfield definitions
//extern volatile bit FP0                @ ((unsigned)&CANCON_RO4*8)+0;
//extern volatile bit WIN0_FP1           @ ((unsigned)&CANCON_RO4*8)+1;
//extern volatile bit WIN1_FP2           @ ((unsigned)&CANCON_RO4*8)+2;
//extern volatile bit WIN2_FP3           @ ((unsigned)&CANCON_RO4*8)+3;
//extern volatile bit ABAT               @ ((unsigned)&CANCON_RO4*8)+4;
//extern volatile bit REQOP0             @ ((unsigned)&CANCON_RO4*8)+5;
//extern volatile bit REQOP1             @ ((unsigned)&CANCON_RO4*8)+6;
//extern volatile bit REQOP2             @ ((unsigned)&CANCON_RO4*8)+7;
//extern volatile bit WIN0               @ ((unsigned)&CANCON_RO4*8)+1;
//extern volatile bit WIN1               @ ((unsigned)&CANCON_RO4*8)+2;
//extern volatile bit WIN2               @ ((unsigned)&CANCON_RO4*8)+3;
extern union {
    struct {
        volatile unsigned FP0                 : 1;
        volatile unsigned WIN0_FP1            : 1;
        volatile unsigned WIN1_FP2            : 1;
        volatile unsigned WIN2_FP3            : 1;
        volatile unsigned ABAT                : 1;
        volatile unsigned REQOP0              : 1;
        volatile unsigned REQOP1              : 1;
        volatile unsigned REQOP2              : 1;
    };
    struct {
        volatile unsigned : 1;
        volatile unsigned : 1;
        volatile unsigned : 1;
        volatile unsigned : 1;
        volatile unsigned : 1;
        volatile unsigned REQOP               : 3;
    };
    struct {
        volatile unsigned                     : 1;
        volatile unsigned WIN0                : 1;
        volatile unsigned WIN1                : 1;
        volatile unsigned WIN2                : 1;
    };
} CANCON_RO4bits @ 0xE7F;

//
// 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 volatile bit EXIDE              @ ((unsigned)&RXF0SIDL*8)+3;
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;
    };
    struct {
        volatile unsigned : 3;
        volatile unsigned EXIDE               : 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 volatile bit EXIDE              @ ((unsigned)&RXF1SIDL*8)+3;
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;
    };
    struct {
        volatile unsigned : 3;
        volatile unsigned EXIDE               : 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 volatile bit EXIDE              @ ((unsigned)&RXF2SIDL*8)+3;
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;
    };
    struct {
        volatile unsigned : 3;
        volatile unsigned EXIDE               : 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 volatile bit EXIDE              @ ((unsigned)&RXF3SIDL*8)+3;
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;
    };
    struct {
        volatile unsigned : 3;
        volatile unsigned EXIDE               : 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 volatile bit EXIDE              @ ((unsigned)&RXF4SIDL*8)+3;
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;
    };
    struct {
        volatile unsigned : 3;
        volatile unsigned EXIDE               : 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 volatile bit EXIDE              @ ((unsigned)&RXF5SIDL*8)+3;
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;
    };
    struct {
        volatile unsigned : 3;
        volatile unsigned EXIDE               : 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 EXIDEN             @ ((unsigned)&RXM0SIDL*8)+3;
//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                     : 1;
        volatile unsigned EXIDEN              : 1;
        volatile unsigned : 1;
        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 EXIDEN             @ ((unsigned)&RXM1SIDL*8)+3;
//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                     : 1;
        volatile unsigned EXIDEN              : 1;
        volatile unsigned : 1;
        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 volatile bit TXBIF              @ ((unsigned)&TXB2CON*8)+7;
extern volatile bit TXBIFBXB2CON        @ ((unsigned)&TXB2CON*8)+7;
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;
        volatile unsigned TXBIF               : 1;
    };
    struct {
        volatile unsigned : 7;
        volatile unsigned TXBIFBXB2CON        : 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: CANSTAT_RO3
extern volatile unsigned char           CANSTAT_RO3         @ 0xF2E;
// bit and bitfield definitions
//extern volatile bit EICODE0            @ ((unsigned)&CANSTAT_RO3*8)+0;
//extern volatile bit EICODE1_ICODE0     @ ((unsigned)&CANSTAT_RO3*8)+1;
//extern volatile bit EICODE2_ICODE1     @ ((unsigned)&CANSTAT_RO3*8)+2;
//extern volatile bit EICODE3_ICODE2     @ ((unsigned)&CANSTAT_RO3*8)+3;
//extern volatile bit EICODE4            @ ((unsigned)&CANSTAT_RO3*8)+4;
//extern volatile bit OPMODE0            @ ((unsigned)&CANSTAT_RO3*8)+5;
//extern volatile bit OPMODE1            @ ((unsigned)&CANSTAT_RO3*8)+6;
//extern volatile bit OPMODE2            @ ((unsigned)&CANSTAT_RO3*8)+7;
//extern volatile bit ICODE0             @ ((unsigned)&CANSTAT_RO3*8)+0;
//extern volatile bit ICODE1             @ ((unsigned)&CANSTAT_RO3*8)+1;
//extern volatile bit ICODE2             @ ((unsigned)&CANSTAT_RO3*8)+2;
//extern volatile bit ICODE3             @ ((unsigned)&CANSTAT_RO3*8)+3;
//extern volatile bit ICODE4             @ ((unsigned)&CANSTAT_RO3*8)+4;
extern union {
    struct {
        volatile unsigned EICODE0             : 1;
        volatile unsigned EICODE1_ICODE0      : 1;
        volatile unsigned EICODE2_ICODE1      : 1;
        volatile unsigned EICODE3_ICODE2      : 1;
        volatile unsigned EICODE4             : 1;
        volatile unsigned OPMODE0             : 1;
        volatile unsigned OPMODE1             : 1;
        volatile unsigned OPMODE2             : 1;
    };
    struct {
        volatile unsigned : 1;
        volatile unsigned : 1;
        volatile unsigned : 1;
        volatile unsigned : 1;
        volatile unsigned : 1;
        volatile unsigned OPMODE              : 3;
    };
    struct {
        volatile unsigned ICODE0              : 1;
        volatile unsigned ICODE1              : 1;
        volatile unsigned ICODE2              : 1;
        volatile unsigned ICODE3              : 1;
        volatile unsigned ICODE4              : 1;
    };
} CANSTAT_RO3bits @ 0xF2E;

// Register: CANCON_RO3
extern volatile unsigned char           CANCON_RO3          @ 0xF2F;
// bit and bitfield definitions
//extern volatile bit FP0                @ ((unsigned)&CANCON_RO3*8)+0;
//extern volatile bit WIN0_FP1           @ ((unsigned)&CANCON_RO3*8)+1;
//extern volatile bit WIN1_FP2           @ ((unsigned)&CANCON_RO3*8)+2;
//extern volatile bit WIN2_FP3           @ ((unsigned)&CANCON_RO3*8)+3;
//extern volatile bit ABAT               @ ((unsigned)&CANCON_RO3*8)+4;
//extern volatile bit REQOP0             @ ((unsigned)&CANCON_RO3*8)+5;
//extern volatile bit REQOP1             @ ((unsigned)&CANCON_RO3*8)+6;
//extern volatile bit REQOP2             @ ((unsigned)&CANCON_RO3*8)+7;
//extern volatile bit WIN0               @ ((unsigned)&CANCON_RO3*8)+1;
//extern volatile bit WIN1               @ ((unsigned)&CANCON_RO3*8)+2;
//extern volatile bit WIN2               @ ((unsigned)&CANCON_RO3*8)+3;
extern union {
    struct {
        volatile unsigned FP0                 : 1;
        volatile unsigned WIN0_FP1            : 1;
        volatile unsigned WIN1_FP2            : 1;
        volatile unsigned WIN2_FP3            : 1;
        volatile unsigned ABAT                : 1;
        volatile unsigned REQOP0              : 1;
        volatile unsigned REQOP1              : 1;
        volatile unsigned REQOP2              : 1;
    };
    struct {
        volatile unsigned : 1;
        volatile unsigned : 1;
        volatile unsigned : 1;
        volatile unsigned : 1;
        volatile unsigned : 1;
        volatile unsigned REQOP               : 3;
    };
    struct {
        volatile unsigned                     : 1;
        volatile unsigned WIN0                : 1;
        volatile unsigned WIN1                : 1;
        volatile unsigned WIN2                : 1;
    };
} CANCON_RO3bits @ 0xF2F;

// 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 volatile bit TXBIF              @ ((unsigned)&TXB1CON*8)+7;
extern volatile bit TXBIFTXB1CON        @ ((unsigned)&TXB1CON*8)+7;
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;
        volatile unsigned TXBIF               : 1;
    };
    struct {
        volatile unsigned : 7;
        volatile unsigned TXBIFTXB1CON        : 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 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;
    };
} 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: CANSTAT_RO2
extern volatile unsigned char           CANSTAT_RO2         @ 0xF3E;
// bit and bitfield definitions
//extern volatile bit EICODE0            @ ((unsigned)&CANSTAT_RO2*8)+0;
//extern volatile bit EICODE1_ICODE0     @ ((unsigned)&CANSTAT_RO2*8)+1;
//extern volatile bit EICODE2_ICODE1     @ ((unsigned)&CANSTAT_RO2*8)+2;
//extern volatile bit EICODE3_ICODE2     @ ((unsigned)&CANSTAT_RO2*8)+3;
//extern volatile bit EICODE4            @ ((unsigned)&CANSTAT_RO2*8)+4;
//extern volatile bit OPMODE0            @ ((unsigned)&CANSTAT_RO2*8)+5;
//extern volatile bit OPMODE1            @ ((unsigned)&CANSTAT_RO2*8)+6;
//extern volatile bit OPMODE2            @ ((unsigned)&CANSTAT_RO2*8)+7;
//extern volatile bit ICODE0             @ ((unsigned)&CANSTAT_RO2*8)+0;
//extern volatile bit ICODE1             @ ((unsigned)&CANSTAT_RO2*8)+1;
//extern volatile bit ICODE2             @ ((unsigned)&CANSTAT_RO2*8)+2;
//extern volatile bit ICODE3             @ ((unsigned)&CANSTAT_RO2*8)+3;
//extern volatile bit ICODE4             @ ((unsigned)&CANSTAT_RO2*8)+4;
extern union {
    struct {
        volatile unsigned EICODE0             : 1;
        volatile unsigned EICODE1_ICODE0      : 1;
        volatile unsigned EICODE2_ICODE1      : 1;
        volatile unsigned EICODE3_ICODE2      : 1;
        volatile unsigned EICODE4             : 1;
        volatile unsigned OPMODE0             : 1;
        volatile unsigned OPMODE1             : 1;
        volatile unsigned OPMODE2             : 1;
    };
    struct {
        volatile unsigned : 1;
        volatile unsigned : 1;
        volatile unsigned : 1;
        volatile unsigned : 1;
        volatile unsigned : 1;
        volatile unsigned OPMODE              : 3;
    };
    struct {
        volatile unsigned ICODE0              : 1;
        volatile unsigned ICODE1              : 1;
        volatile unsigned ICODE2              : 1;
        volatile unsigned ICODE3              : 1;
        volatile unsigned ICODE4              : 1;
    };
} CANSTAT_RO2bits @ 0xF3E;

// Register: CANCON_RO2
extern volatile unsigned char           CANCON_RO2          @ 0xF3F;
// bit and bitfield definitions
//extern volatile bit FP0                @ ((unsigned)&CANCON_RO2*8)+0;
//extern volatile bit WIN0_FP1           @ ((unsigned)&CANCON_RO2*8)+1;
//extern volatile bit WIN1_FP2           @ ((unsigned)&CANCON_RO2*8)+2;
//extern volatile bit WIN2_FP3           @ ((unsigned)&CANCON_RO2*8)+3;
//extern volatile bit ABAT               @ ((unsigned)&CANCON_RO2*8)+4;
//extern volatile bit REQOP0             @ ((unsigned)&CANCON_RO2*8)+5;
//extern volatile bit REQOP1             @ ((unsigned)&CANCON_RO2*8)+6;
//extern volatile bit REQOP2             @ ((unsigned)&CANCON_RO2*8)+7;
//extern volatile bit WIN0               @ ((unsigned)&CANCON_RO2*8)+1;
//extern volatile bit WIN1               @ ((unsigned)&CANCON_RO2*8)+2;
//extern volatile bit WIN2               @ ((unsigned)&CANCON_RO2*8)+3;
extern union {
    struct {
        volatile unsigned FP0                 : 1;
        volatile unsigned WIN0_FP1            : 1;
        volatile unsigned WIN1_FP2            : 1;
        volatile unsigned WIN2_FP3            : 1;
        volatile unsigned ABAT                : 1;
        volatile unsigned REQOP0              : 1;
        volatile unsigned REQOP1              : 1;
        volatile unsigned REQOP2              : 1;
    };
    struct {
        volatile unsigned : 1;
        volatile unsigned : 1;
        volatile unsigned : 1;
        volatile unsigned : 1;
        volatile unsigned : 1;
        volatile unsigned REQOP               : 3;
    };
    struct {
        volatile unsigned                     : 1;
        volatile unsigned WIN0                : 1;
        volatile unsigned WIN1                : 1;
        volatile unsigned WIN2                : 1;
    };
} CANCON_RO2bits @ 0xF3F;

// 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 volatile bit TXBIF              @ ((unsigned)&TXB0CON*8)+7;
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;
        volatile unsigned TXBIF               : 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: CANSTAT_RO1
extern volatile unsigned char           CANSTAT_RO1         @ 0xF4E;
// bit and bitfield definitions
//extern volatile bit EICODE0            @ ((unsigned)&CANSTAT_RO1*8)+0;
//extern volatile bit EICODE1_ICODE0     @ ((unsigned)&CANSTAT_RO1*8)+1;
//extern volatile bit EICODE2_ICODE1     @ ((unsigned)&CANSTAT_RO1*8)+2;
//extern volatile bit EICODE3_ICODE2     @ ((unsigned)&CANSTAT_RO1*8)+3;
//extern volatile bit EICODE4            @ ((unsigned)&CANSTAT_RO1*8)+4;
//extern volatile bit OPMODE0            @ ((unsigned)&CANSTAT_RO1*8)+5;
//extern volatile bit OPMODE1            @ ((unsigned)&CANSTAT_RO1*8)+6;
//extern volatile bit OPMODE2            @ ((unsigned)&CANSTAT_RO1*8)+7;
//extern volatile bit ICODE0             @ ((unsigned)&CANSTAT_RO1*8)+0;
//extern volatile bit ICODE1             @ ((unsigned)&CANSTAT_RO1*8)+1;
//extern volatile bit ICODE2             @ ((unsigned)&CANSTAT_RO1*8)+2;
//extern volatile bit ICODE3             @ ((unsigned)&CANSTAT_RO1*8)+3;
//extern volatile bit ICODE4             @ ((unsigned)&CANSTAT_RO1*8)+4;
extern union {
    struct {
        volatile unsigned EICODE0             : 1;
        volatile unsigned EICODE1_ICODE0      : 1;
        volatile unsigned EICODE2_ICODE1      : 1;
        volatile unsigned EICODE3_ICODE2      : 1;
        volatile unsigned EICODE4             : 1;
        volatile unsigned OPMODE0             : 1;
        volatile unsigned OPMODE1             : 1;
        volatile unsigned OPMODE2             : 1;
    };
    struct {
        volatile unsigned : 1;
        volatile unsigned : 1;
        volatile unsigned : 1;
        volatile unsigned : 1;
        volatile unsigned : 1;
        volatile unsigned OPMODE              : 3;
    };
    struct {
        volatile unsigned ICODE0              : 1;
        volatile unsigned ICODE1              : 1;
        volatile unsigned ICODE2              : 1;
        volatile unsigned ICODE3              : 1;
        volatile unsigned ICODE4              : 1;
    };
} CANSTAT_RO1bits @ 0xF4E;

// Register: CANCON_RO1
extern volatile unsigned char           CANCON_RO1          @ 0xF4F;
// bit and bitfield definitions
//extern volatile bit FP0                @ ((unsigned)&CANCON_RO1*8)+0;
//extern volatile bit WIN0_FP1           @ ((unsigned)&CANCON_RO1*8)+1;
//extern volatile bit WIN1_FP2           @ ((unsigned)&CANCON_RO1*8)+2;
//extern volatile bit WIN2_FP3           @ ((unsigned)&CANCON_RO1*8)+3;
//extern volatile bit ABAT               @ ((unsigned)&CANCON_RO1*8)+4;
//extern volatile bit REQOP0             @ ((unsigned)&CANCON_RO1*8)+5;
//extern volatile bit REQOP1             @ ((unsigned)&CANCON_RO1*8)+6;
//extern volatile bit REQOP2             @ ((unsigned)&CANCON_RO1*8)+7;
//extern volatile bit WIN0               @ ((unsigned)&CANCON_RO1*8)+1;
//extern volatile bit WIN1               @ ((unsigned)&CANCON_RO1*8)+2;
//extern volatile bit WIN2               @ ((unsigned)&CANCON_RO1*8)+3;
extern union {
    struct {
        volatile unsigned FP0                 : 1;
        volatile unsigned WIN0_FP1            : 1;
        volatile unsigned WIN1_FP2            : 1;
        volatile unsigned WIN2_FP3            : 1;
        volatile unsigned ABAT                : 1;
        volatile unsigned REQOP0              : 1;
        volatile unsigned REQOP1              : 1;
        volatile unsigned REQOP2              : 1;
    };
    struct {
        volatile unsigned : 1;
        volatile unsigned : 1;
        volatile unsigned : 1;
        volatile unsigned : 1;
        volatile unsigned : 1;
        volatile unsigned REQOP               : 3;
    };
    struct {
        volatile unsigned                     : 1;
        volatile unsigned WIN0                : 1;
        volatile unsigned WIN1                : 1;
        volatile unsigned WIN2                : 1;
    };
} CANCON_RO1bits @ 0xF4F;

// 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_FILHIT3    @ ((unsigned)&RXB1CON*8)+3;
//extern volatile bit FILHIT4            @ ((unsigned)&RXB1CON*8)+4;
//extern volatile bit RXM0_RTRRO         @ ((unsigned)&RXB1CON*8)+5;
//extern volatile bit RXM1               @ ((unsigned)&RXB1CON*8)+6;
//extern volatile bit RXFUL              @ ((unsigned)&RXB1CON*8)+7;
//extern volatile bit RXRTRRO            @ ((unsigned)&RXB1CON*8)+3;
//extern volatile bit RXM0               @ ((unsigned)&RXB1CON*8)+5;
//extern volatile bit FILHIT3            @ ((unsigned)&RXB1CON*8)+3;
//extern volatile bit RTRRO              @ ((unsigned)&RXB1CON*8)+5;
extern union {
    struct {
        volatile unsigned FILHIT0             : 1;
        volatile unsigned FILHIT1             : 1;
        volatile unsigned FILHIT2             : 1;
        volatile unsigned RXRTRRO_FILHIT3     : 1;
        volatile unsigned FILHIT4             : 1;
        volatile unsigned RXM0_RTRRO          : 1;
        volatile unsigned RXM1                : 1;
        volatile unsigned RXFUL               : 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                     : 3;
        volatile unsigned RXRTRRO             : 1;
        volatile unsigned : 1;
        volatile unsigned RXM0                : 1;
    };
    struct {
        volatile unsigned : 3;
        volatile unsigned FILHIT3             : 1;
        volatile unsigned : 1;
        volatile unsigned RTRRO               : 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 RESRB0             @ ((unsigned)&RXB1DLC*8)+4;
//extern volatile bit RESRB1             @ ((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 RESRB0              : 1;
        volatile unsigned RESRB1              : 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: CANSTAT_RO0
extern volatile unsigned char           CANSTAT_RO0         @ 0xF5E;
// bit and bitfield definitions
//extern volatile bit EICODE0            @ ((unsigned)&CANSTAT_RO0*8)+0;
//extern volatile bit EICODE1_ICODE0     @ ((unsigned)&CANSTAT_RO0*8)+1;
//extern volatile bit EICODE2_ICODE1     @ ((unsigned)&CANSTAT_RO0*8)+2;
//extern volatile bit EICODE3_ICODE2     @ ((unsigned)&CANSTAT_RO0*8)+3;
//extern volatile bit EICODE4            @ ((unsigned)&CANSTAT_RO0*8)+4;
//extern volatile bit OPMODE0            @ ((unsigned)&CANSTAT_RO0*8)+5;
//extern volatile bit OPMODE1            @ ((unsigned)&CANSTAT_RO0*8)+6;
//extern volatile bit OPMODE2            @ ((unsigned)&CANSTAT_RO0*8)+7;
//extern volatile bit ICODE0             @ ((unsigned)&CANSTAT_RO0*8)+0;
//extern volatile bit ICODE1             @ ((unsigned)&CANSTAT_RO0*8)+1;
//extern volatile bit ICODE2             @ ((unsigned)&CANSTAT_RO0*8)+2;
//extern volatile bit ICODE3             @ ((unsigned)&CANSTAT_RO0*8)+3;
//extern volatile bit ICODE4             @ ((unsigned)&CANSTAT_RO0*8)+4;
extern union {
    struct {
        volatile unsigned EICODE0             : 1;
        volatile unsigned EICODE1_ICODE0      : 1;
        volatile unsigned EICODE2_ICODE1      : 1;
        volatile unsigned EICODE3_ICODE2      : 1;
        volatile unsigned EICODE4             : 1;
        volatile unsigned OPMODE0             : 1;
        volatile unsigned OPMODE1             : 1;
        volatile unsigned OPMODE2             : 1;
    };
    struct {
        volatile unsigned : 1;
        volatile unsigned : 1;
        volatile unsigned : 1;
        volatile unsigned : 1;
        volatile unsigned : 1;
        volatile unsigned OPMODE              : 3;
    };
    struct {
        volatile unsigned ICODE0              : 1;
        volatile unsigned ICODE1              : 1;
        volatile unsigned ICODE2              : 1;
        volatile unsigned ICODE3              : 1;
        volatile unsigned ICODE4              : 1;
    };
} CANSTAT_RO0bits @ 0xF5E;

// Register: CANCON_RO0
extern volatile unsigned char           CANCON_RO0          @ 0xF5F;
// bit and bitfield definitions
//extern volatile bit FP0                @ ((unsigned)&CANCON_RO0*8)+0;
//extern volatile bit WIN0_FP1           @ ((unsigned)&CANCON_RO0*8)+1;
//extern volatile bit WIN1_FP2           @ ((unsigned)&CANCON_RO0*8)+2;
//extern volatile bit WIN2_FP3           @ ((unsigned)&CANCON_RO0*8)+3;
//extern volatile bit ABAT               @ ((unsigned)&CANCON_RO0*8)+4;
//extern volatile bit REQOP0             @ ((unsigned)&CANCON_RO0*8)+5;
//extern volatile bit REQOP1             @ ((unsigned)&CANCON_RO0*8)+6;
//extern volatile bit REQOP2             @ ((unsigned)&CANCON_RO0*8)+7;
//extern volatile bit WIN0               @ ((unsigned)&CANCON_RO0*8)+1;
//extern volatile bit WIN1               @ ((unsigned)&CANCON_RO0*8)+2;
//extern volatile bit WIN2               @ ((unsigned)&CANCON_RO0*8)+3;
extern union {
    struct {
        volatile unsigned FP0                 : 1;
        volatile unsigned WIN0_FP1            : 1;
        volatile unsigned WIN1_FP2            : 1;
        volatile unsigned WIN2_FP3            : 1;
        volatile unsigned ABAT                : 1;
        volatile unsigned REQOP0              : 1;
        volatile unsigned REQOP1              : 1;
        volatile unsigned REQOP2              : 1;
    };
    struct {
        volatile unsigned : 1;
        volatile unsigned : 1;
        volatile unsigned : 1;
        volatile unsigned : 1;
        volatile unsigned : 1;
        volatile unsigned REQOP               : 3;
    };
    struct {
        volatile unsigned                     : 1;
        volatile unsigned WIN0                : 1;
        volatile unsigned WIN1                : 1;
        volatile unsigned WIN2                : 1;
    };
} CANCON_RO0bits @ 0xF5F;

//
// 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_FILHIT1       @ ((unsigned)&RXB0CON*8)+1;
extern volatile bit RXB0DBEN_FILHIT2    @ ((unsigned)&RXB0CON*8)+2;
//extern volatile bit RXRTRRO_FILHIT3    @ ((unsigned)&RXB0CON*8)+3;
//extern volatile bit FILHIT4            @ ((unsigned)&RXB0CON*8)+4;
//extern volatile bit RXM0_RTRRO         @ ((unsigned)&RXB0CON*8)+5;
//extern volatile bit RXM1               @ ((unsigned)&RXB0CON*8)+6;
//extern volatile bit RXFUL              @ ((unsigned)&RXB0CON*8)+7;
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 FILHIT1            @ ((unsigned)&RXB0CON*8)+1;
//extern volatile bit FILHIT2            @ ((unsigned)&RXB0CON*8)+2;
//extern volatile bit FILHIT3            @ ((unsigned)&RXB0CON*8)+3;
//extern volatile bit RTRRO              @ ((unsigned)&RXB0CON*8)+5;
extern volatile bit RXBODBEN            @ ((unsigned)&RXB0CON*8)+2;
extern union {
    struct {
        volatile unsigned FILHIT0             : 1;
        volatile unsigned JTOFF_FILHIT1       : 1;
        volatile unsigned RXB0DBEN_FILHIT2    : 1;
        volatile unsigned RXRTRRO_FILHIT3     : 1;
        volatile unsigned FILHIT4             : 1;
        volatile unsigned RXM0_RTRRO          : 1;
        volatile unsigned RXM1                : 1;
        volatile unsigned RXFUL               : 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 JTOFF               : 1;
        volatile unsigned RXB0DBEN            : 1;
        volatile unsigned RXRTRRO             : 1;
        volatile unsigned : 1;
        volatile unsigned RXM0                : 1;
    };
    struct {
        volatile unsigned : 1;
        volatile unsigned FILHIT1             : 1;
        volatile unsigned FILHIT2             : 1;
        volatile unsigned FILHIT3             : 1;
        volatile unsigned : 1;
        volatile unsigned RTRRO               : 1;
    };
    struct {
        volatile unsigned : 2;
        volatile unsigned RXBODBEN            : 1;
    };
} 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 RESRB0             @ ((unsigned)&RXB0DLC*8)+4;
//extern volatile bit RESRB1             @ ((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 RESRB0              : 1;
        volatile unsigned RESRB1              : 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 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;
    };
} 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 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;
    };
} 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 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;
    };
} 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 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;
    };
} 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 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;
    };
} 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 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;
    };
} 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 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;
    };
} 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 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;
    };
} RXB0D7bits @ 0xF6D;

// Register: CANSTAT
extern volatile unsigned char           CANSTAT             @ 0xF6E;
// bit and bitfield definitions
//extern volatile bit EICODE0            @ ((unsigned)&CANSTAT*8)+0;
//extern volatile bit EICODE1_ICODE0     @ ((unsigned)&CANSTAT*8)+1;
//extern volatile bit EICODE2_ICODE1     @ ((unsigned)&CANSTAT*8)+2;
//extern volatile bit EICODE3_ICODE2     @ ((unsigned)&CANSTAT*8)+3;
//extern volatile bit EICODE4            @ ((unsigned)&CANSTAT*8)+4;
//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 volatile bit ICODE0             @ ((unsigned)&CANSTAT*8)+0;
//extern volatile bit ICODE1             @ ((unsigned)&CANSTAT*8)+1;
//extern volatile bit ICODE2             @ ((unsigned)&CANSTAT*8)+2;
//extern volatile bit ICODE3             @ ((unsigned)&CANSTAT*8)+3;
extern volatile bit EICODE1             @ ((unsigned)&CANSTAT*8)+1;
extern volatile bit EICODE2             @ ((unsigned)&CANSTAT*8)+2;
extern volatile bit EICODE3             @ ((unsigned)&CANSTAT*8)+3;
extern union {
    struct {
        volatile unsigned EICODE0             : 1;
        volatile unsigned EICODE1_ICODE0      : 1;
        volatile unsigned EICODE2_ICODE1      : 1;
        volatile unsigned EICODE3_ICODE2      : 1;
        volatile unsigned EICODE4             : 1;
        volatile unsigned OPMODE0             : 1;
        volatile unsigned OPMODE1             : 1;
        volatile unsigned OPMODE2             : 1;
    };
    struct {
        volatile unsigned : 1;
        volatile unsigned : 1;
        volatile unsigned : 1;
        volatile unsigned : 1;
        volatile unsigned : 1;
        volatile unsigned OPMODE              : 3;
    };
    struct {
        volatile unsigned ICODE0              : 1;
        volatile unsigned ICODE1              : 1;
        volatile unsigned ICODE2              : 1;
        volatile unsigned ICODE3              : 1;
    };
    struct {
        volatile unsigned                     : 1;
        volatile unsigned EICODE1             : 1;
        volatile unsigned EICODE2             : 1;
        volatile unsigned EICODE3             : 1;
    };
} CANSTATbits @ 0xF6E;

// Register: CANCON
extern volatile unsigned char           CANCON              @ 0xF6F;
// bit and bitfield definitions
//extern volatile bit FP0                @ ((unsigned)&CANCON*8)+0;
//extern volatile bit WIN0_FP1           @ ((unsigned)&CANCON*8)+1;
//extern volatile bit WIN1_FP2           @ ((unsigned)&CANCON*8)+2;
//extern volatile bit WIN2_FP3           @ ((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 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 FP1                 @ ((unsigned)&CANCON*8)+1;
extern volatile bit FP2                 @ ((unsigned)&CANCON*8)+2;
extern volatile bit FP3                 @ ((unsigned)&CANCON*8)+3;
extern union {
    struct {
        volatile unsigned FP0                 : 1;
        volatile unsigned WIN0_FP1            : 1;
        volatile unsigned WIN1_FP2            : 1;
        volatile unsigned WIN2_FP3            : 1;
        volatile unsigned ABAT                : 1;
        volatile unsigned REQOP0              : 1;
        volatile unsigned REQOP1              : 1;
        volatile unsigned REQOP2              : 1;
    };
    struct {
        volatile unsigned : 1;
        volatile unsigned : 1;
        volatile unsigned : 1;
        volatile unsigned : 1;
        volatile unsigned : 1;
        volatile unsigned REQOP               : 3;
    };
    struct {
        volatile unsigned                     : 1;
        volatile unsigned WIN0                : 1;
        volatile unsigned WIN1                : 1;
        volatile unsigned WIN2                : 1;
    };
    struct {
        volatile unsigned : 1;
        volatile unsigned FP1                 : 1;
        volatile unsigned FP2                 : 1;
        volatile unsigned FP3                 : 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 SEG2PHT             @ ((unsigned)&BRGCON2*8)+7;
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 SEG2PHT             : 1;
    };
    struct {
        volatile unsigned                     : 7;
        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 volatile bit WAKDIS              @ ((unsigned)&BRGCON3*8)+7;
extern union {
    struct {
        volatile unsigned SEG2PH0             : 1;
        volatile unsigned SEG2PH1             : 1;
        volatile unsigned SEG2PH2             : 1;
        volatile unsigned                     : 3;
        volatile unsigned WAKFIL              : 1;
        volatile unsigned WAKDIS              : 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 RXBnOVFL            @ ((unsigned)&COMSTAT*8)+6;
extern volatile bit RXB0OVFL_nFIFOEMPTY @ ((unsigned)&COMSTAT*8)+7;
extern volatile bit RXB1OVFL            @ ((unsigned)&COMSTAT*8)+6;
extern volatile bit RXB0OVFL            @ ((unsigned)&COMSTAT*8)+7;
extern volatile bit FIFOEMPTY           @ ((unsigned)&COMSTAT*8)+7;
extern volatile bit nFIFOEMPTY          @ ((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 RXBnOVFL            : 1;
        volatile unsigned RXB0OVFL_nFIFOEMPTY : 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                     : 6;
        volatile unsigned RXB1OVFL            : 1;
        volatile unsigned RXB0OVFL            : 1;
    };
    struct {
        volatile unsigned : 7;
        volatile unsigned FIFOEMPTY           : 1;
    };
    struct {
        volatile unsigned : 7;
        volatile unsigned nFIFOEMPTY          : 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: ECANCON
extern volatile unsigned char           ECANCON             @ 0xF77;
// bit and bitfield definitions
extern volatile bit EWIN0               @ ((unsigned)&ECANCON*8)+0;
extern volatile bit EWIN1               @ ((unsigned)&ECANCON*8)+1;
extern volatile bit EWIN2               @ ((unsigned)&ECANCON*8)+2;
extern volatile bit EWIN3               @ ((unsigned)&ECANCON*8)+3;
extern volatile bit EWIN4               @ ((unsigned)&ECANCON*8)+4;
extern volatile bit FIFOWM              @ ((unsigned)&ECANCON*8)+5;
extern volatile bit MDSEL0              @ ((unsigned)&ECANCON*8)+6;
extern volatile bit MDSEL1              @ ((unsigned)&ECANCON*8)+7;
extern volatile bit F                   @ ((unsigned)&ECANCON*8)+5;
extern union {
    struct {
        volatile unsigned EWIN0               : 1;
        volatile unsigned EWIN1               : 1;
        volatile unsigned EWIN2               : 1;
        volatile unsigned EWIN3               : 1;
        volatile unsigned EWIN4               : 1;
        volatile unsigned FIFOWM              : 1;
        volatile unsigned MDSEL0              : 1;
        volatile unsigned MDSEL1              : 1;
    };
    struct {
        volatile unsigned                     : 5;
        volatile unsigned F                   : 1;
    };
} ECANCONbits @ 0xF77;

// 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 RA7                @ ((unsigned)&PORTA*8)+7;
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 T0CKI               @ ((unsigned)&PORTA*8)+4;
extern volatile bit AN4                 @ ((unsigned)&PORTA*8)+5;
extern volatile bit OSC2                @ ((unsigned)&PORTA*8)+6;
extern volatile bit OSC1                @ ((unsigned)&PORTA*8)+7;
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 HLVDIN              @ ((unsigned)&PORTA*8)+5;
extern volatile bit CLKO                @ ((unsigned)&PORTA*8)+6;
extern volatile bit CLKI                @ ((unsigned)&PORTA*8)+7;
extern volatile bit LVDIN               @ ((unsigned)&PORTA*8)+5;
extern volatile bit SS                  @ ((unsigned)&PORTA*8)+5;
extern volatile bit nSS                 @ ((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;
        volatile unsigned RA7                 : 1;
    };
    struct {
        volatile unsigned AN0                 : 1;
        volatile unsigned AN1                 : 1;
        volatile unsigned AN2                 : 1;
        volatile unsigned AN3                 : 1;
        volatile unsigned T0CKI               : 1;
        volatile unsigned AN4                 : 1;
        volatile unsigned OSC2                : 1;
        volatile unsigned OSC1                : 1;
    };
    struct {
        volatile unsigned CVREF               : 1;
        volatile unsigned                     : 1;
        volatile unsigned VREFM               : 1;
        volatile unsigned VREFP               : 1;
        volatile unsigned : 1;
        volatile unsigned HLVDIN              : 1;
        volatile unsigned CLKO                : 1;
        volatile unsigned CLKI                : 1;
    };
    struct {
        volatile unsigned : 5;
        volatile unsigned LVDIN               : 1;
    };
    struct {
        volatile unsigned : 5;
        volatile unsigned SS                  : 1;
    };
    struct {
        volatile unsigned : 5;
        volatile unsigned nSS                 : 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 INT2                @ ((unsigned)&PORTB*8)+2;
extern volatile bit CANRX               @ ((unsigned)&PORTB*8)+3;
extern volatile bit KBI0                @ ((unsigned)&PORTB*8)+4;
extern volatile bit KBI1                @ ((unsigned)&PORTB*8)+5;
extern volatile bit KBI2                @ ((unsigned)&PORTB*8)+6;
extern volatile bit KBI3                @ ((unsigned)&PORTB*8)+7;
extern volatile bit AN10                @ ((unsigned)&PORTB*8)+0;
extern volatile bit AN8                 @ ((unsigned)&PORTB*8)+1;
extern volatile bit CANTX               @ ((unsigned)&PORTB*8)+2;
extern volatile bit AN9                 @ ((unsigned)&PORTB*8)+4;
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 volatile bit FLT0                @ ((unsigned)&PORTB*8)+0;
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 INT2                : 1;
        volatile unsigned CANRX               : 1;
        volatile unsigned KBI0                : 1;
        volatile unsigned KBI1                : 1;
        volatile unsigned KBI2                : 1;
        volatile unsigned KBI3                : 1;
    };
    struct {
        volatile unsigned AN10                : 1;
        volatile unsigned AN8                 : 1;
        volatile unsigned CANTX               : 1;
        volatile unsigned                     : 1;
        volatile unsigned AN9                 : 1;
        volatile unsigned PGM                 : 1;
        volatile unsigned PGC                 : 1;
        volatile unsigned PGD                 : 1;
    };
    struct {
        volatile unsigned FLT0                : 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 CCP1                @ ((unsigned)&PORTC*8)+2;
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 T13CKI              @ ((unsigned)&PORTC*8)+0;
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 CCP1                : 1;
        volatile unsigned SCK                 : 1;
        volatile unsigned SDI                 : 1;
        volatile unsigned SDO                 : 1;
        volatile unsigned TX                  : 1;
        volatile unsigned RX                  : 1;
    };
    struct {
        volatile unsigned T13CKI              : 1;
        volatile unsigned                     : 2;
        volatile unsigned SCL                 : 1;
        volatile unsigned SDA                 : 1;
        volatile unsigned : 1;
        volatile unsigned CK                  : 1;
        volatile unsigned DT                  : 1;
    };
} PORTCbits @ 0xF82;

// Register: PORTE
extern volatile unsigned char           PORTE               @ 0xF84;
// bit and bitfield definitions
extern volatile bit RE3                 @ ((unsigned)&PORTE*8)+3;
extern union {
    struct {
        volatile unsigned                     : 3;
        volatile unsigned RE3                 : 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 volatile bit LATA7               @ ((unsigned)&LATA*8)+7;
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;
        volatile unsigned LATA7               : 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: 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 TRISA7              @ ((unsigned)&TRISA*8)+7;
//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 volatile bit RA7                @ ((unsigned)&TRISA*8)+7;
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;
        volatile unsigned TRISA7              : 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;
        volatile unsigned RA7                 : 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: OSCTUNE
extern volatile unsigned char           OSCTUNE             @ 0xF9B;
// bit and bitfield definitions
extern volatile bit PLLEN               @ ((unsigned)&OSCTUNE*8)+6;
extern volatile bit INTSRC              @ ((unsigned)&OSCTUNE*8)+7;
extern volatile bit TUN0                @ ((unsigned)&OSCTUNE*8)+0;
extern volatile bit TUN1                @ ((unsigned)&OSCTUNE*8)+1;
extern volatile bit TUN2                @ ((unsigned)&OSCTUNE*8)+2;
extern volatile bit TUN3                @ ((unsigned)&OSCTUNE*8)+3;
extern volatile bit TUN4                @ ((unsigned)&OSCTUNE*8)+4;
extern volatile bit INTSCR              @ ((unsigned)&OSCTUNE*8)+7;
extern union {
    struct {
        volatile unsigned TUN                 : 5;
        volatile unsigned                     : 1;
        volatile unsigned PLLEN               : 1;
        volatile unsigned INTSRC              : 1;
    };
    struct {
        volatile unsigned TUN0                : 1;
        volatile unsigned TUN1                : 1;
        volatile unsigned TUN2                : 1;
        volatile unsigned TUN3                : 1;
        volatile unsigned TUN4                : 1;
        volatile unsigned : 2;
        volatile unsigned INTSCR              : 1;
    };
} OSCTUNEbits @ 0xF9B;

// 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 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;
    };
} 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 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;
    };
    struct {
        volatile unsigned : 1;
        volatile unsigned : 1;
        volatile unsigned : 1;
        volatile unsigned : 1;
        volatile unsigned                     : 2;
        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 TXBIP               @ ((unsigned)&IPR1*8)+4;
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;
    };
    struct {
        volatile unsigned                     : 4;
        volatile unsigned TXBIP               : 1;
    };
} IPR1bits @ 0xF9F;

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

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

// Register: IPR2
extern volatile unsigned char           IPR2                @ 0xFA2;
// bit and bitfield definitions
extern volatile bit TMR3IP              @ ((unsigned)&IPR2*8)+1;
extern volatile bit HLVDIP              @ ((unsigned)&IPR2*8)+2;
extern volatile bit BCLIP               @ ((unsigned)&IPR2*8)+3;
extern volatile bit EEIP                @ ((unsigned)&IPR2*8)+4;
extern volatile bit OSCFIP              @ ((unsigned)&IPR2*8)+7;
extern volatile bit LVDIP               @ ((unsigned)&IPR2*8)+2;
extern union {
    struct {
        volatile unsigned                     : 1;
        volatile unsigned TMR3IP              : 1;
        volatile unsigned HLVDIP              : 1;
        volatile unsigned BCLIP               : 1;
        volatile unsigned EEIP                : 1;
        volatile unsigned : 2;
        volatile unsigned OSCFIP              : 1;
    };
    struct {
        volatile unsigned : 2;
        volatile unsigned LVDIP               : 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 FIFOWMIE            @ ((unsigned)&PIE3*8)+0;
extern volatile bit RXBnIE              @ ((unsigned)&PIE3*8)+1;
extern volatile bit TXBnIE              @ ((unsigned)&PIE3*8)+4;
extern volatile bit FIFOMWIE            @ ((unsigned)&PIE3*8)+0;
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 FIFOWMIE            : 1;
        volatile unsigned RXBnIE              : 1;
        volatile unsigned                     : 2;
        volatile unsigned TXBnIE              : 1;
    };
    struct {
        volatile unsigned FIFOMWIE            : 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 FIFOWMIF            @ ((unsigned)&PIR3*8)+0;
extern volatile bit RXBnIF              @ ((unsigned)&PIR3*8)+1;
extern volatile bit TXBnIF              @ ((unsigned)&PIR3*8)+4;
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 FIFOWMIF            : 1;
        volatile unsigned RXBnIF              : 1;
        volatile unsigned                     : 2;
        volatile unsigned TXBnIF              : 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 FIFOWMIP            @ ((unsigned)&IPR3*8)+0;
extern volatile bit RXBnIP              @ ((unsigned)&IPR3*8)+1;
extern volatile bit TXBnIP              @ ((unsigned)&IPR3*8)+4;
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 FIFOWMIP            : 1;
        volatile unsigned RXBnIP              : 1;
        volatile unsigned                     : 2;
        volatile unsigned TXBnIP              : 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 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;
    };
} 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: EEADRH
extern volatile unsigned char           EEADRH              @ 0xFAA;
// bit and bitfield definitions
extern union {
    struct {
        volatile unsigned                     : 2;
    };
} EEADRHbits @ 0xFAA;

// 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 ADEN                @ ((unsigned)&RCSTA*8)+3;
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                     : 3;
        volatile unsigned ADEN                : 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 SENDB               @ ((unsigned)&TXSTA*8)+3;
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 union {
    struct {
        volatile unsigned TX9D                : 1;
        volatile unsigned TRMT                : 1;
        volatile unsigned BRGH                : 1;
        volatile unsigned SENDB               : 1;
        volatile unsigned SYNC                : 1;
        volatile unsigned TXEN                : 1;
        volatile unsigned TX9                 : 1;
        volatile unsigned CSRC                : 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: SPBRGH
extern volatile unsigned char           SPBRGH              @ 0xFB0;
// 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 T3SYNC              @ ((unsigned)&T3CON*8)+2;
extern volatile bit T3CKPS0             @ ((unsigned)&T3CON*8)+4;
extern volatile bit T3CKPS1             @ ((unsigned)&T3CON*8)+5;
extern volatile bit T3CCP2              @ ((unsigned)&T3CON*8)+6;
extern volatile bit T3NSYNC             @ ((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 T3SYNC              : 1;
        volatile unsigned : 1;
        volatile unsigned T3CKPS0             : 1;
        volatile unsigned T3CKPS1             : 1;
        volatile unsigned T3CCP2              : 1;
    };
    struct {
        volatile unsigned : 2;
        volatile unsigned T3NSYNC             : 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: ECCP1AS
extern volatile unsigned char           ECCP1AS             @ 0xFB6;
// bit and bitfield definitions
extern volatile bit ECCPASE             @ ((unsigned)&ECCP1AS*8)+7;
extern volatile bit PSSAC0              @ ((unsigned)&ECCP1AS*8)+2;
extern volatile bit PSSAC1              @ ((unsigned)&ECCP1AS*8)+3;
extern volatile bit ECCPAS0             @ ((unsigned)&ECCP1AS*8)+4;
extern volatile bit ECCPAS1             @ ((unsigned)&ECCP1AS*8)+5;
extern volatile bit ECCPAS2             @ ((unsigned)&ECCP1AS*8)+6;
extern union {
    struct {
        volatile unsigned                     : 2;
        volatile unsigned PSSAC               : 2;
        volatile unsigned ECCPAS              : 3;
        volatile unsigned ECCPASE             : 1;
    };
    struct {
        volatile unsigned : 2;
        volatile unsigned PSSAC0              : 1;
        volatile unsigned PSSAC1              : 1;
        volatile unsigned ECCPAS0             : 1;
        volatile unsigned ECCPAS1             : 1;
        volatile unsigned ECCPAS2             : 1;
    };
} ECCP1ASbits @ 0xFB6;

// Register: ECCP1DEL
extern volatile unsigned char           ECCP1DEL            @ 0xFB7;
// bit and bitfield definitions
extern volatile bit PRSEN               @ ((unsigned)&ECCP1DEL*8)+7;
extern union {
    struct {
        volatile unsigned                     : 7;
        volatile unsigned PRSEN               : 1;
    };
} ECCP1DELbits @ 0xFB7;

// Register: BAUDCON
extern volatile unsigned char           BAUDCON             @ 0xFB8;
extern volatile unsigned char           BAUDCTL             @ 0xFB8;
// bit and bitfield definitions
extern volatile bit ABDEN               @ ((unsigned)&BAUDCON*8)+0;
extern volatile bit WUE                 @ ((unsigned)&BAUDCON*8)+1;
extern volatile bit BRG16               @ ((unsigned)&BAUDCON*8)+3;
extern volatile bit TXCKP               @ ((unsigned)&BAUDCON*8)+4;
extern volatile bit RXDTP               @ ((unsigned)&BAUDCON*8)+5;
extern volatile bit RCIDL               @ ((unsigned)&BAUDCON*8)+6;
extern volatile bit ABDOVF              @ ((unsigned)&BAUDCON*8)+7;
extern volatile bit SCKP                @ ((unsigned)&BAUDCON*8)+4;
extern union {
    struct {
        volatile unsigned ABDEN               : 1;
        volatile unsigned WUE                 : 1;
        volatile unsigned                     : 1;
        volatile unsigned BRG16               : 1;
        volatile unsigned TXCKP               : 1;
        volatile unsigned RXDTP               : 1;
        volatile unsigned RCIDL               : 1;
        volatile unsigned ABDOVF              : 1;
    };
    struct {
        volatile unsigned : 4;
        volatile unsigned SCKP                : 1;
    };
} BAUDCONbits @ 0xFB8;

// 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 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;
    };
} 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: ADCON2
extern volatile unsigned char           ADCON2              @ 0xFC0;
// bit and bitfield definitions
extern volatile bit ADFM                @ ((unsigned)&ADCON2*8)+7;
extern volatile bit ADCS0               @ ((unsigned)&ADCON2*8)+0;
extern volatile bit ADCS1               @ ((unsigned)&ADCON2*8)+1;
extern volatile bit ADCS2               @ ((unsigned)&ADCON2*8)+2;
extern volatile bit ACQT0               @ ((unsigned)&ADCON2*8)+3;
extern volatile bit ACQT1               @ ((unsigned)&ADCON2*8)+4;
extern volatile bit ACQT2               @ ((unsigned)&ADCON2*8)+5;
extern union {
    struct {
        volatile unsigned ADCS                : 3;
        volatile unsigned ACQT                : 3;
        volatile unsigned                     : 1;
        volatile unsigned ADFM                : 1;
    };
    struct {
        volatile unsigned ADCS0               : 1;
        volatile unsigned ADCS1               : 1;
        volatile unsigned ADCS2               : 1;
        volatile unsigned ACQT0               : 1;
        volatile unsigned ACQT1               : 1;
        volatile unsigned ACQT2               : 1;
    };
} ADCON2bits @ 0xFC0;

// Register: ADCON1
extern volatile unsigned char           ADCON1              @ 0xFC1;
// bit and bitfield definitions
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 volatile bit VCFG0               @ ((unsigned)&ADCON1*8)+4;
extern volatile bit VCFG1               @ ((unsigned)&ADCON1*8)+5;
extern union {
    struct {
        volatile unsigned PCFG                : 4;
        volatile unsigned VCFG                : 2;
    };
    struct {
        volatile unsigned PCFG0               : 1;
        volatile unsigned PCFG1               : 1;
        volatile unsigned PCFG2               : 1;
        volatile unsigned PCFG3               : 1;
        volatile unsigned VCFG0               : 1;
        volatile unsigned VCFG1               : 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)+1;
extern volatile bit GO_DONE             @ ((unsigned)&ADCON0*8)+1;
extern volatile bit CHS0                @ ((unsigned)&ADCON0*8)+2;
extern volatile bit CHS1                @ ((unsigned)&ADCON0*8)+3;
extern volatile bit CHS2                @ ((unsigned)&ADCON0*8)+4;
extern volatile bit CHS3                @ ((unsigned)&ADCON0*8)+5;
extern volatile bit DONE                @ ((unsigned)&ADCON0*8)+1;
extern volatile bit GO                  @ ((unsigned)&ADCON0*8)+1;
extern volatile bit nDONE               @ ((unsigned)&ADCON0*8)+1;
extern union {
    struct {
        volatile unsigned ADON                : 1;
        volatile unsigned GO_nDONE            : 1;
        volatile unsigned CHS                 : 4;
    };
    struct {
        volatile unsigned : 1;
        volatile unsigned : 1;
        volatile unsigned : 4;
    };
    struct {
        volatile unsigned                     : 1;
        volatile unsigned GO_DONE             : 1;
        volatile unsigned CHS0                : 1;
        volatile unsigned CHS1                : 1;
        volatile unsigned CHS2                : 1;
        volatile unsigned CHS3                : 1;
    };
    struct {
        volatile unsigned : 1;
        volatile unsigned DONE                : 1;
    };
    struct {
        volatile unsigned : 1;
        volatile unsigned GO                  : 1;
    };
    struct {
        volatile unsigned : 1;
        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 R_W                 @ ((unsigned)&SSPSTAT*8)+2;
extern volatile bit D_A                 @ ((unsigned)&SSPSTAT*8)+5;
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_DAT             @ ((unsigned)&SSPSTAT*8)+5;
extern volatile bit nW                  @ ((unsigned)&SSPSTAT*8)+2;
extern volatile bit nA                  @ ((unsigned)&SSPSTAT*8)+5;
extern volatile bit nWRITE              @ ((unsigned)&SSPSTAT*8)+2;
extern volatile bit nADDRESS            @ ((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 R                   @ ((unsigned)&SSPSTAT*8)+2;
extern volatile bit D                   @ ((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 R_W                 : 1;
        volatile unsigned : 2;
        volatile unsigned D_A                 : 1;
    };
    struct {
        volatile unsigned : 2;
        volatile unsigned I2C_READ            : 1;
        volatile unsigned I2C_START           : 1;
        volatile unsigned I2C_STOP            : 1;
        volatile unsigned I2C_DAT             : 1;
    };
    struct {
        volatile unsigned : 2;
        volatile unsigned nW                  : 1;
        volatile unsigned : 2;
        volatile unsigned nA                  : 1;
    };
    struct {
        volatile unsigned : 2;
        volatile unsigned nWRITE              : 1;
        volatile unsigned : 2;
        volatile unsigned nADDRESS            : 1;
    };
    struct {
        volatile unsigned : 2;
        volatile unsigned READ_WRITE          : 1;
        volatile unsigned : 2;
        volatile unsigned DATA_ADDRESS        : 1;
    };
    struct {
        volatile unsigned : 2;
        volatile unsigned R                   : 1;
        volatile unsigned : 2;
        volatile unsigned D                   : 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 T2OUTPS0            @ ((unsigned)&T2CON*8)+3;
extern volatile bit T2OUTPS1            @ ((unsigned)&T2CON*8)+4;
extern volatile bit T2OUTPS2            @ ((unsigned)&T2CON*8)+5;
extern volatile bit T2OUTPS3            @ ((unsigned)&T2CON*8)+6;
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 T2OUTPS             : 4;
    };
    struct {
        volatile unsigned T2CKPS0             : 1;
        volatile unsigned T2CKPS1             : 1;
        volatile unsigned                     : 1;
        volatile unsigned T2OUTPS0            : 1;
        volatile unsigned T2OUTPS1            : 1;
        volatile unsigned T2OUTPS2            : 1;
        volatile unsigned T2OUTPS3            : 1;
    };
    struct {
        volatile unsigned : 3;
        volatile unsigned TOUTPS              : 4;
    };
    struct {
        volatile unsigned : 3;
        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 T1RUN               @ ((unsigned)&T1CON*8)+6;
//extern volatile bit RD16               @ ((unsigned)&T1CON*8)+7;
extern volatile bit T1SYNC              @ ((unsigned)&T1CON*8)+2;
extern volatile bit T1CKPS0             @ ((unsigned)&T1CON*8)+4;
extern volatile bit T1CKPS1             @ ((unsigned)&T1CON*8)+5;
extern volatile bit T1INSYNC            @ ((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 T1RUN               : 1;
        volatile unsigned RD16                : 1;
    };
    struct {
        volatile unsigned                     : 2;
        volatile unsigned T1SYNC              : 1;
        volatile unsigned : 1;
        volatile unsigned T1CKPS0             : 1;
        volatile unsigned T1CKPS1             : 1;
    };
    struct {
        volatile unsigned : 2;
        volatile unsigned T1INSYNC            : 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 SBOREN              @ ((unsigned)&RCON*8)+6;
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 union {
    struct {
        volatile unsigned nBOR                : 1;
        volatile unsigned nPOR                : 1;
        volatile unsigned nPD                 : 1;
        volatile unsigned nTO                 : 1;
        volatile unsigned nRI                 : 1;
        volatile unsigned                     : 1;
        volatile unsigned SBOREN              : 1;
        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;
    };
} 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: HLVDCON
extern volatile unsigned char           HLVDCON             @ 0xFD2;
extern volatile unsigned char           LVDCON              @ 0xFD2;
// bit and bitfield definitions
extern volatile bit HLVDEN              @ ((unsigned)&HLVDCON*8)+4;
extern volatile bit IRVST               @ ((unsigned)&HLVDCON*8)+5;
extern volatile bit VDIRMAG             @ ((unsigned)&HLVDCON*8)+7;
extern volatile bit HLVDL0              @ ((unsigned)&HLVDCON*8)+0;
extern volatile bit HLVDL1              @ ((unsigned)&HLVDCON*8)+1;
extern volatile bit HLVDL2              @ ((unsigned)&HLVDCON*8)+2;
extern volatile bit HLVDL3              @ ((unsigned)&HLVDCON*8)+3;
extern volatile bit LVDL0               @ ((unsigned)&HLVDCON*8)+0;
extern volatile bit LVDL1               @ ((unsigned)&HLVDCON*8)+1;
extern volatile bit LVDL2               @ ((unsigned)&HLVDCON*8)+2;
extern volatile bit LVDL3               @ ((unsigned)&HLVDCON*8)+3;
extern volatile bit LVDEN               @ ((unsigned)&HLVDCON*8)+4;
extern volatile bit IVRST               @ ((unsigned)&HLVDCON*8)+5;
extern volatile bit LVV0                @ ((unsigned)&HLVDCON*8)+0;
extern volatile bit LVV1                @ ((unsigned)&HLVDCON*8)+1;
extern volatile bit LVV2                @ ((unsigned)&HLVDCON*8)+2;
extern volatile bit LVV3                @ ((unsigned)&HLVDCON*8)+3;
extern volatile bit BGST                @ ((unsigned)&HLVDCON*8)+5;
extern union {
    struct {
        volatile unsigned HLVDL               : 4;
        volatile unsigned HLVDEN              : 1;
        volatile unsigned IRVST               : 1;
        volatile unsigned                     : 1;
        volatile unsigned VDIRMAG             : 1;
    };
    struct {
        volatile unsigned HLVDL0              : 1;
        volatile unsigned HLVDL1              : 1;
        volatile unsigned HLVDL2              : 1;
        volatile unsigned HLVDL3              : 1;
    };
    struct {
        volatile unsigned LVDL0               : 1;
        volatile unsigned LVDL1               : 1;
        volatile unsigned LVDL2               : 1;
        volatile unsigned LVDL3               : 1;
        volatile unsigned LVDEN               : 1;
        volatile unsigned IVRST               : 1;
    };
    struct {
        volatile unsigned LVV0                : 1;
        volatile unsigned LVV1                : 1;
        volatile unsigned LVV2                : 1;
        volatile unsigned LVV3                : 1;
        volatile unsigned : 1;
        volatile unsigned BGST                : 1;
    };
} HLVDCONbits @ 0xFD2;

// Register: OSCCON
extern volatile unsigned char           OSCCON              @ 0xFD3;
// bit and bitfield definitions
extern volatile bit IOFS                @ ((unsigned)&OSCCON*8)+2;
extern volatile bit OSTS                @ ((unsigned)&OSCCON*8)+3;
extern volatile bit IDLEN               @ ((unsigned)&OSCCON*8)+7;
extern volatile bit SCS0                @ ((unsigned)&OSCCON*8)+0;
extern volatile bit SCS1                @ ((unsigned)&OSCCON*8)+1;
extern volatile bit IRCF0               @ ((unsigned)&OSCCON*8)+4;
extern volatile bit IRCF1               @ ((unsigned)&OSCCON*8)+5;
extern volatile bit IRCF2               @ ((unsigned)&OSCCON*8)+6;
extern union {
    struct {
        volatile unsigned SCS                 : 2;
        volatile unsigned IOFS                : 1;
        volatile unsigned OSTS                : 1;
        volatile unsigned IRCF                : 3;
        volatile unsigned IDLEN               : 1;
    };
    struct {
        volatile unsigned SCS0                : 1;
        volatile unsigned SCS1                : 1;
        volatile unsigned                     : 2;
        volatile unsigned IRCF0               : 1;
        volatile unsigned IRCF1               : 1;
        volatile unsigned IRCF2               : 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 volatile bit T0PS3               @ ((unsigned)&T0CON*8)+3;
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;
        volatile unsigned T0PS3               : 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;
// 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;
// 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 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;
    };
} 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

Translate Assembly procedure to C Language:

Code:

LATA = 0x00;
ADCON1 = 0x0F;
CMCON = 0x07;
TRISA = 0xFF;

marven2320 said:
I want to detect if portA.f0 is trigged by setting portc.f0 equal to 1 but my code didnt work well.

You'll need to post your code with a detailed description of its intend tasks.

BigDog

marven2320 · Jul 26, 2012

Here is the code I made.

#include<p18f2680.h>

void main(){

TRISA = 0xFF; // Configure PORTA as input
TRISC = 0; // Configure PORTC as output
PORTC = 0x00;

while(1){
If(PORAbits.RA0 == 0){
LATCbits.LATC0 = 1;
}

}

}

Is there some command missing? please help. Thanks!

bigdogguru · Jul 26, 2012

marven2320 said:
Is there some command missing? please help. Thanks!

Yes.

Well obviously you did not bother to read my lengthy reply. :shock:

Code:

// To disable the analog functions of PORTA

LATA = 0x00;
ADCON1 = 0x0F;
CMCON = 0x07;
TRISA = 0xFF;     // configure to the appropriate direction

BigDog

LightDiodeDesigns · Jul 26, 2012

Yeah, CMCON needs clearing to give the analogue pin back..

Well, for ports direction, just clear PORTx, if you want to set it as output (example: PORTC=0), and you must set PORTx if you wish to set it as input (example: PORTA=255).

Wrong, didly wrong
NEAL

marven2320 · Jul 26, 2012

Thanks!
It helps me a lot on making DIGITAL INPUT on portA and DIGITAL OUTPUT on portC. My code is working fine now.
Thank you.

Can you show me a short example on UART syntax?

Below is the code in mikroC:

Code C - [expand]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
char uart_rd;
 
void main() {
     //  ANSEL  = 0;                     // Configure AN pins as digital  ANSELH = 0;  
     UART1_Init(9600);               // Initialize UART module at 9600 bps
     Delay_ms(100);                  // Wait for UART module to stabilize  
     UART1_Write_Text("Start");  UART1_Write(10);  UART1_Write(13);  
     while (1) {                     // Endless loop
        if (UART1_Data_Ready()) {     // If data is received,
             uart_rd = UART1_Read();     // read the received data,
             UART1_Write(uart_rd);       // and send data via UART  
        }
 
    }
 
}

-----With PIC18f2680, Can you show me the equivalent code in MPLAB in C Language?

LightDiodeDesigns · Jul 27, 2012

Code:

    #define SPBRG_VAL   ( ((64000000/BAUD_RATE)/16) - 1)
    
    #if SPBRG_VAL > 255
        #error "Calculated SPBRG value is out of range for currnet CLOCK_FREQ."
    #endif
        
    void ConsoleInit(void)
    {
	//OSCTUNEbits.PLLEN =0;
	OSCCONbits.IRCF=7;

	TRISC7 = 1;
	TRISC6 = 1;
         TXSTA = 0b00101100; // 0x2C;
// SPEN RX9 SREN CREN ADDEN FERR OERR RX9D
         RCSTA = 0b10110000;
	SPBRGH=0; 	
	BAUDCONbits.BRG16 = 0;
	TXSTAbits.BRGH = 0;
    SPBRG =  SPBRG_VAL;
	TXSTAbits.SENDB=1;	
		

    }// thanks to microchip's console.c

This is my init code for an 18f4685, to hone the Baud-rate whenI was testing, I'd send a stream of data (the actual BRG value) out the port and make the code "jiggle" the BRG until I couldread it in putty, and I'm running a 64MHz clocked chip, insert your own speed
Cool indeed, have fn I hope
Neal

bmandl · Jul 27, 2012

LightDiodeDesigns said:
Yeah, CMCON needs clearing to give the analogue pin back..

Wrong, didly wrong
NEAL

Ups, I am sorry. Replace PORTx with TRISx. I was in hurry and I made a mistake.

- - - Updated - - -

For the UART in Hitech C, look at the samples in saples folder:

C:\Program Files (x86)\HI-TECH Software\PICC\version\samples

Welcome to EDAboard.com

PIC18f2680 with MPLAB using C

marven2320

Junior Member level 1

bmandl

Full Member level 4

marven2320

Junior Member level 1

bigdogguru

Administrator

marven2320

Junior Member level 1

bigdogguru

Administrator

LightDiodeDesigns

Advanced Member level 4

marven2320

Junior Member level 1

LightDiodeDesigns

Advanced Member level 4

bmandl

Full Member level 4

Similar threads

Part and Inventory Search

Welcome to EDABoard.com

Sponsor

Connect with us

Online statistics

Forum statistics