#ifndef MS32F7362_H
#define MS32F7362_H

#include <mc32-common.h>

//
// Register addresses.
//
#define INDF0_ADDR      	0x0180
#define INDF1_ADDR      	0x0181
#define INDF2_ADDR      	0x0182
#define HIBYTE_ADDR     	0x0183
#define FSR0_ADDR       	0x0184
#define FSR1_ADDR       	0x0185
#define PCL_ADDR        	0x0186
#define PFLAG_ADDR      	0x0187
#define MCR_ADDR        	0x0188
#define INDF3_ADDR      	0x0189
#define INTE0_ADDR      	0x018A
#define INTF0_ADDR      	0x018B
#define OSCMR_ADDR      	0x018C
#define INTE1_ADDR      	0x018E
#define INTF1_ADDR      	0x018F
#define IOP0_ADDR       	0x0190
#define OEP0_ADDR       	0x0191
#define PUP0_ADDR       	0x0192
#define PDP0_ADDR       	0x0193
#define IOP1_ADDR       	0x0194
#define OEP1_ADDR       	0x0195
#define PUP1_ADDR       	0x0196
#define PDP1_ADDR       	0x0197
#define IOP2_ADDR       	0x0198
#define OEP2_ADDR       	0x0199
#define PUP2_ADDR       	0x019A
#define PDP2_ADDR       	0x019B
#define P1KBCR_ADDR     	0x019C
#define P2KBCR_ADDR     	0x019D
#define LVDCR_ADDR      	0x019F
#define T0CR_ADDR       	0x01A0
#define T0CNT_ADDR      	0x01A1
#define T0LOAD_ADDR     	0x01A2
#define HIRCCAL_ADDR    	0x01A5
#define DBGCR_ADDR      	0x01A6
#define DBGPR_ADDR      	0x01A7
#define T1CR0_ADDR      	0x01A8
#define T1CR1_ADDR      	0x01A9
#define T1CNTH_ADDR     	0x01AA
#define T1CNTL_ADDR     	0x01AB
#define T1LOADH_ADDR    	0x01AC
#define T1LOADL_ADDR    	0x01AD
#define T2CR_ADDR       	0x01B0
#define T2CNT_ADDR      	0x01B1
#define T2LOAD_ADDR     	0x01B2
#define T2DATA_ADDR     	0x01B3
#define T2DATB_ADDR     	0x01B4
#define T2DATC_ADDR     	0x01B5
#define PWM2CR0_ADDR    	0x01B6
#define PWM2CR1_ADDR    	0x01B7
#define PWM2CR2_ADDR    	0x01B8
#define EECR_ADDR       	0x01C3
#define EEPR_ADDR       	0x01C4
#define EEAR_ADDR       	0x01C5
#define EEDRH_ADDR      	0x01C6
#define EEDRL_ADDR      	0x01C7
#define ADCR0_ADDR      	0x01C8
#define ADCR1_ADDR      	0x01C9
#define ADRH_ADDR       	0x01CA
#define ADRL_ADDR       	0x01CB
#define OSADJCR_ADDR    	0x01CC
#define P0ADCR_ADDR     	0x01CD
#define P1ADCR_ADDR     	0x01CE
#define P2ADCR_ADDR     	0x01CF
#define OPCR0_ADDR      	0x01D0
#define OPCR1_ADDR      	0x01D1
#define OPCR2_ADDR      	0x01D2
#define OP0VRH_ADDR     	0x01D3
#define OP0VRL_ADDR     	0x01D4
#define OP1VRH_ADDR     	0x01D5
#define OP1VRL_ADDR     	0x01D6
#define OP2CLR_ADDR     	0x01D7
#define URTCR0_ADDR     	0x01D8
#define URTCR1_ADDR     	0x01D9
#define URTCR2_ADDR     	0x01DA
#define URTSR_ADDR      	0x01DB
#define URTBR_ADDR      	0x01DC
#define URTDR_ADDR      	0x01DD
#define URTAR_ADDR      	0x01DE
#define URTMR_ADDR      	0x01DF

//----- Register Files -----------------------------------------------------

extern __sfr __at (INDF0_ADDR)    	INDF0;
extern __sfr __at (INDF1_ADDR)    	INDF1;
extern __sfr __at (INDF2_ADDR)    	INDF2;
extern __sfr __at (HIBYTE_ADDR)   	HIBYTE;
extern __sfr __at (FSR0_ADDR)     	FSR0;
extern __sfr __at (FSR1_ADDR)     	FSR1;
extern __sfr __at (PCL_ADDR)      	PCL;
extern __sfr __at (PFLAG_ADDR)    	PFLAG;
extern __sfr __at (MCR_ADDR)      	MCR;
extern __sfr __at (INDF3_ADDR)    	INDF3;
extern __sfr __at (INTE0_ADDR)    	INTE0;
extern __sfr __at (INTF0_ADDR)    	INTF0;
extern __sfr __at (OSCMR_ADDR)    	OSCMR;
extern __sfr __at (INTE1_ADDR)    	INTE1;
extern __sfr __at (INTF1_ADDR)    	INTF1;
extern __sfr __at (IOP0_ADDR)     	IOP0;
extern __sfr __at (OEP0_ADDR)     	OEP0;
extern __sfr __at (PUP0_ADDR)     	PUP0;
extern __sfr __at (PDP0_ADDR)     	PDP0;
extern __sfr __at (IOP1_ADDR)     	IOP1;
extern __sfr __at (OEP1_ADDR)     	OEP1;
extern __sfr __at (PUP1_ADDR)     	PUP1;
extern __sfr __at (PDP1_ADDR)     	PDP1;
extern __sfr __at (IOP2_ADDR)     	IOP2;
extern __sfr __at (OEP2_ADDR)     	OEP2;
extern __sfr __at (PUP2_ADDR)     	PUP2;
extern __sfr __at (PDP2_ADDR)     	PDP2;
extern __sfr __at (P1KBCR_ADDR)   	P1KBCR;
extern __sfr __at (P2KBCR_ADDR)   	P2KBCR;
extern __sfr __at (LVDCR_ADDR)    	LVDCR;
extern __sfr __at (T0CR_ADDR)     	T0CR;
extern __sfr __at (T0CNT_ADDR)    	T0CNT;
extern __sfr __at (T0LOAD_ADDR)   	T0LOAD;
extern __sfr __at (HIRCCAL_ADDR)  	HIRCCAL;
extern __sfr __at (DBGCR_ADDR)    	DBGCR;
extern __sfr __at (DBGPR_ADDR)    	DBGPR;
extern __sfr __at (T1CR0_ADDR)    	T1CR0;
extern __sfr __at (T1CR1_ADDR)    	T1CR1;
extern __sfr __at (T1CNTH_ADDR)   	T1CNTH;
extern __sfr __at (T1CNTL_ADDR)   	T1CNTL;
extern __sfr __at (T1LOADH_ADDR)  	T1LOADH;
extern __sfr __at (T1LOADL_ADDR)  	T1LOADL;
extern __sfr __at (T2CR_ADDR)     	T2CR;
extern __sfr __at (T2CNT_ADDR)    	T2CNT;
extern __sfr __at (T2LOAD_ADDR)   	T2LOAD;
extern __sfr __at (T2DATA_ADDR)   	T2DATA;
extern __sfr __at (T2DATB_ADDR)   	T2DATB;
extern __sfr __at (T2DATC_ADDR)   	T2DATC;
extern __sfr __at (PWM2CR0_ADDR)  	PWM2CR0;
extern __sfr __at (PWM2CR1_ADDR)  	PWM2CR1;
extern __sfr __at (PWM2CR2_ADDR)  	PWM2CR2;
extern __sfr __at (EECR_ADDR)     	EECR;
extern __sfr __at (EEPR_ADDR)     	EEPR;
extern __sfr __at (EEAR_ADDR)     	EEAR;
extern __sfr __at (EEDRH_ADDR)    	EEDRH;
extern __sfr __at (EEDRL_ADDR)    	EEDRL;
extern __sfr __at (ADCR0_ADDR)    	ADCR0;
extern __sfr __at (ADCR1_ADDR)    	ADCR1;
extern __sfr __at (ADRH_ADDR)     	ADRH;
extern __sfr __at (ADRL_ADDR)     	ADRL;
extern __sfr __at (OSADJCR_ADDR)  	OSADJCR;
extern __sfr __at (P0ADCR_ADDR)   	P0ADCR;
extern __sfr __at (P1ADCR_ADDR)   	P1ADCR;
extern __sfr __at (P2ADCR_ADDR)   	P2ADCR;
extern __sfr __at (OPCR0_ADDR)    	OPCR0;
extern __sfr __at (OPCR1_ADDR)    	OPCR1;
extern __sfr __at (OPCR2_ADDR)    	OPCR2;
extern __sfr __at (OP0VRH_ADDR)   	OP0VRH;
extern __sfr __at (OP0VRL_ADDR)   	OP0VRL;
extern __sfr __at (OP1VRH_ADDR)   	OP1VRH;
extern __sfr __at (OP1VRL_ADDR)   	OP1VRL;
extern __sfr __at (OP2CLR_ADDR)   	OP2CLR;
extern __sfr __at (URTCR0_ADDR)   	URTCR0;
extern __sfr __at (URTCR1_ADDR)   	URTCR1;
extern __sfr __at (URTCR2_ADDR)   	URTCR2;
extern __sfr __at (URTSR_ADDR)    	URTSR;
extern __sfr __at (URTBR_ADDR)    	URTBR;
extern __sfr __at (URTDR_ADDR)    	URTDR;
extern __sfr __at (URTAR_ADDR)    	URTAR;
extern __sfr __at (URTMR_ADDR)    	URTMR;

//==========================================================================
//
//	Configuration Bits
//
//==========================================================================

//OPBIT1

//OPBIT0

// ----- INDF0 Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char INDF00:1;
		unsigned char INDF01:1;
		unsigned char INDF02:1;
		unsigned char INDF03:1;
		unsigned char INDF04:1;
		unsigned char INDF05:1;
		unsigned char INDF06:1;
		unsigned char INDF07:1;
	};
} __INDF0bits_t;
extern volatile __INDF0bits_t __at(INDF0_ADDR) INDF0bits;

#define INDF00    	INDF0bits.INDF00    	/* bit 0 */
#define INDF01    	INDF0bits.INDF01    	/* bit 1 */
#define INDF02    	INDF0bits.INDF02    	/* bit 2 */
#define INDF03    	INDF0bits.INDF03    	/* bit 3 */
#define INDF04    	INDF0bits.INDF04    	/* bit 4 */
#define INDF05    	INDF0bits.INDF05    	/* bit 5 */
#define INDF06    	INDF0bits.INDF06    	/* bit 6 */
#define INDF07    	INDF0bits.INDF07    	/* bit 7 */

// ----- INDF1 Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char INDF10:1;
		unsigned char INDF11:1;
		unsigned char INDF12:1;
		unsigned char INDF13:1;
		unsigned char INDF14:1;
		unsigned char INDF15:1;
		unsigned char INDF16:1;
		unsigned char INDF17:1;
	};
} __INDF1bits_t;
extern volatile __INDF1bits_t __at(INDF1_ADDR) INDF1bits;

#define INDF10    	INDF1bits.INDF10    	/* bit 0 */
#define INDF11    	INDF1bits.INDF11    	/* bit 1 */
#define INDF12    	INDF1bits.INDF12    	/* bit 2 */
#define INDF13    	INDF1bits.INDF13    	/* bit 3 */
#define INDF14    	INDF1bits.INDF14    	/* bit 4 */
#define INDF15    	INDF1bits.INDF15    	/* bit 5 */
#define INDF16    	INDF1bits.INDF16    	/* bit 6 */
#define INDF17    	INDF1bits.INDF17    	/* bit 7 */

// ----- INDF2 Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char INDF20:1;
		unsigned char INDF21:1;
		unsigned char INDF22:1;
		unsigned char INDF23:1;
		unsigned char INDF24:1;
		unsigned char INDF25:1;
		unsigned char INDF26:1;
		unsigned char INDF27:1;
	};
} __INDF2bits_t;
extern volatile __INDF2bits_t __at(INDF2_ADDR) INDF2bits;

#define INDF20    	INDF2bits.INDF20    	/* bit 0 */
#define INDF21    	INDF2bits.INDF21    	/* bit 1 */
#define INDF22    	INDF2bits.INDF22    	/* bit 2 */
#define INDF23    	INDF2bits.INDF23    	/* bit 3 */
#define INDF24    	INDF2bits.INDF24    	/* bit 4 */
#define INDF25    	INDF2bits.INDF25    	/* bit 5 */
#define INDF26    	INDF2bits.INDF26    	/* bit 6 */
#define INDF27    	INDF2bits.INDF27    	/* bit 7 */

// ----- HIBYTE Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char HIBYTE0:1;
		unsigned char HIBYTE1:1;
		unsigned char HIBYTE2:1;
		unsigned char HIBYTE3:1;
		unsigned char HIBYTE4:1;
		unsigned char HIBYTE5:1;
		unsigned char HIBYTE6:1;
		unsigned char HIBYTE7:1;
	};
} __HIBYTEbits_t;
extern volatile __HIBYTEbits_t __at(HIBYTE_ADDR) HIBYTEbits;

#define HIBYTE0   	HIBYTEbits.HIBYTE0  	/* bit 0 */
#define HIBYTE1   	HIBYTEbits.HIBYTE1  	/* bit 1 */
#define HIBYTE2   	HIBYTEbits.HIBYTE2  	/* bit 2 */
#define HIBYTE3   	HIBYTEbits.HIBYTE3  	/* bit 3 */
#define HIBYTE4   	HIBYTEbits.HIBYTE4  	/* bit 4 */
#define HIBYTE5   	HIBYTEbits.HIBYTE5  	/* bit 5 */
#define HIBYTE6   	HIBYTEbits.HIBYTE6  	/* bit 6 */
#define HIBYTE7   	HIBYTEbits.HIBYTE7  	/* bit 7 */

// ----- FSR0 Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char FSR00:1;
		unsigned char FSR01:1;
		unsigned char FSR02:1;
		unsigned char FSR03:1;
		unsigned char FSR04:1;
		unsigned char FSR05:1;
		unsigned char FSR06:1;
		unsigned char FSR07:1;
	};
} __FSR0bits_t;
extern volatile __FSR0bits_t __at(FSR0_ADDR) FSR0bits;

#define FSR00     	FSR0bits.FSR00      	/* bit 0 */
#define FSR01     	FSR0bits.FSR01      	/* bit 1 */
#define FSR02     	FSR0bits.FSR02      	/* bit 2 */
#define FSR03     	FSR0bits.FSR03      	/* bit 3 */
#define FSR04     	FSR0bits.FSR04      	/* bit 4 */
#define FSR05     	FSR0bits.FSR05      	/* bit 5 */
#define FSR06     	FSR0bits.FSR06      	/* bit 6 */
#define FSR07     	FSR0bits.FSR07      	/* bit 7 */

// ----- FSR1 Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char FSR10:1;
		unsigned char FSR11:1;
		unsigned char FSR12:1;
		unsigned char FSR13:1;
		unsigned char FSR14:1;
		unsigned char FSR15:1;
		unsigned char FSR16:1;
		unsigned char FSR17:1;
	};
} __FSR1bits_t;
extern volatile __FSR1bits_t __at(FSR1_ADDR) FSR1bits;

#define FSR10     	FSR1bits.FSR10      	/* bit 0 */
#define FSR11     	FSR1bits.FSR11      	/* bit 1 */
#define FSR12     	FSR1bits.FSR12      	/* bit 2 */
#define FSR13     	FSR1bits.FSR13      	/* bit 3 */
#define FSR14     	FSR1bits.FSR14      	/* bit 4 */
#define FSR15     	FSR1bits.FSR15      	/* bit 5 */
#define FSR16     	FSR1bits.FSR16      	/* bit 6 */
#define FSR17     	FSR1bits.FSR17      	/* bit 7 */

// ----- PCL Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char PC0:1;
		unsigned char PC1:1;
		unsigned char PC2:1;
		unsigned char PC3:1;
		unsigned char PC4:1;
		unsigned char PC5:1;
		unsigned char PC6:1;
		unsigned char PC7:1;
	};
} __PCLbits_t;
extern volatile __PCLbits_t __at(PCL_ADDR) PCLbits;

#define PC0       	PCLbits.PC0         	/* bit 0 */
#define PC1       	PCLbits.PC1         	/* bit 1 */
#define PC2       	PCLbits.PC2         	/* bit 2 */
#define PC3       	PCLbits.PC3         	/* bit 3 */
#define PC4       	PCLbits.PC4         	/* bit 4 */
#define PC5       	PCLbits.PC5         	/* bit 5 */
#define PC6       	PCLbits.PC6         	/* bit 6 */
#define PC7       	PCLbits.PC7         	/* bit 7 */

// ----- PFLAG Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char C:1;
		unsigned char DC:1;
		unsigned char Z:1;
		unsigned char :1;
		unsigned char :1;
		unsigned char :1;
		unsigned char :1;
		unsigned char :1;
	};
} __PFLAGbits_t;
extern volatile __PFLAGbits_t __at(PFLAG_ADDR) PFLAGbits;

#define C         	PFLAGbits.C         	/* bit 0 */
#define DC        	PFLAGbits.DC        	/* bit 1 */
#define Z         	PFLAGbits.Z         	/* bit 2 */

// ----- MCR Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char INT0M0:1;
		unsigned char INT0M1:1;
		unsigned char INT1M0:1;
		unsigned char INT1M1:1;
		unsigned char PD:1;
		unsigned char TO:1;
		unsigned char :1;
		unsigned char GIE:1;
	};
} __MCRbits_t;
extern volatile __MCRbits_t __at(MCR_ADDR) MCRbits;

#define INT0M0    	MCRbits.INT0M0      	/* bit 0 */
#define INT0M1    	MCRbits.INT0M1      	/* bit 1 */
#define INT1M0    	MCRbits.INT1M0      	/* bit 2 */
#define INT1M1    	MCRbits.INT1M1      	/* bit 3 */
#define PD        	MCRbits.PD          	/* bit 4 */
#define TO        	MCRbits.TO          	/* bit 5 */
#define GIE       	MCRbits.GIE         	/* bit 7 */

// ----- INDF3 Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char INDF30:1;
		unsigned char INDF31:1;
		unsigned char INDF32:1;
		unsigned char INDF33:1;
		unsigned char INDF34:1;
		unsigned char INDF35:1;
		unsigned char INDF36:1;
		unsigned char INDF37:1;
	};
} __INDF3bits_t;
extern volatile __INDF3bits_t __at(INDF3_ADDR) INDF3bits;

#define INDF30    	INDF3bits.INDF30    	/* bit 0 */
#define INDF31    	INDF3bits.INDF31    	/* bit 1 */
#define INDF32    	INDF3bits.INDF32    	/* bit 2 */
#define INDF33    	INDF3bits.INDF33    	/* bit 3 */
#define INDF34    	INDF3bits.INDF34    	/* bit 4 */
#define INDF35    	INDF3bits.INDF35    	/* bit 5 */
#define INDF36    	INDF3bits.INDF36    	/* bit 6 */
#define INDF37    	INDF3bits.INDF37    	/* bit 7 */

// ----- INTE0 Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char T0IE:1;
		unsigned char T1IE:1;
		unsigned char INT0IE:1;
		unsigned char INT1IE:1;
		unsigned char KBIE:1;
		unsigned char T2IE:1;
		unsigned char ADIE:1;
		unsigned char LVDIE:1;
	};
} __INTE0bits_t;
extern volatile __INTE0bits_t __at(INTE0_ADDR) INTE0bits;

#define T0IE      	INTE0bits.T0IE      	/* bit 0 */
#define T1IE      	INTE0bits.T1IE      	/* bit 1 */
#define INT0IE    	INTE0bits.INT0IE    	/* bit 2 */
#define INT1IE    	INTE0bits.INT1IE    	/* bit 3 */
#define KBIE      	INTE0bits.KBIE      	/* bit 4 */
#define T2IE      	INTE0bits.T2IE      	/* bit 5 */
#define ADIE      	INTE0bits.ADIE      	/* bit 6 */
#define LVDIE     	INTE0bits.LVDIE     	/* bit 7 */

// ----- INTF0 Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char T0IF:1;
		unsigned char T1IF:1;
		unsigned char INT0IF:1;
		unsigned char INT1IF:1;
		unsigned char KBIF:1;
		unsigned char T2IF:1;
		unsigned char ADIF:1;
		unsigned char LVDIF:1;
	};
} __INTF0bits_t;
extern volatile __INTF0bits_t __at(INTF0_ADDR) INTF0bits;

#define T0IF      	INTF0bits.T0IF      	/* bit 0 */
#define T1IF      	INTF0bits.T1IF      	/* bit 1 */
#define INT0IF    	INTF0bits.INT0IF    	/* bit 2 */
#define INT1IF    	INTF0bits.INT1IF    	/* bit 3 */
#define KBIF      	INTF0bits.KBIF      	/* bit 4 */
#define T2IF      	INTF0bits.T2IF      	/* bit 5 */
#define ADIF      	INTF0bits.ADIF      	/* bit 6 */
#define LVDIF     	INTF0bits.LVDIF     	/* bit 7 */

// ----- OSCMR Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char HFEN:1;
		unsigned char LFEN:1;
		unsigned char CLKS:1;
		unsigned char :1;
		unsigned char STBH:1;
		unsigned char STBL:1;
		unsigned char :1;
		unsigned char :1;
	};
} __OSCMRbits_t;
extern volatile __OSCMRbits_t __at(OSCMR_ADDR) OSCMRbits;

#define HFEN      	OSCMRbits.HFEN      	/* bit 0 */
#define LFEN      	OSCMRbits.LFEN      	/* bit 1 */
#define CLKS      	OSCMRbits.CLKS      	/* bit 2 */
#define STBH      	OSCMRbits.STBH      	/* bit 4 */
#define STBL      	OSCMRbits.STBL      	/* bit 5 */

// ----- INTE1 Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char OP2IE:1;
		unsigned char :1;
		unsigned char T1CIE:1;
		unsigned char RXIE:1;
		unsigned char TXIE:1;
		unsigned char TXBIE:1;
		unsigned char :1;
		unsigned char :1;
	};
} __INTE1bits_t;
extern volatile __INTE1bits_t __at(INTE1_ADDR) INTE1bits;

#define OP2IE     	INTE1bits.OP2IE     	/* bit 0 */
#define T1CIE     	INTE1bits.T1CIE     	/* bit 2 */
#define RXIE      	INTE1bits.RXIE      	/* bit 3 */
#define TXIE      	INTE1bits.TXIE      	/* bit 4 */
#define TXBIE     	INTE1bits.TXBIE     	/* bit 5 */

// ----- INTF1 Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char OP2IF:1;
		unsigned char :1;
		unsigned char T1CIF:1;
		unsigned char RXIF:1;
		unsigned char TXIF:1;
		unsigned char TXBIF:1;
		unsigned char :1;
		unsigned char :1;
	};
} __INTF1bits_t;
extern volatile __INTF1bits_t __at(INTF1_ADDR) INTF1bits;

#define OP2IF     	INTF1bits.OP2IF     	/* bit 0 */
#define T1CIF     	INTF1bits.T1CIF     	/* bit 2 */
#define RXIF      	INTF1bits.RXIF      	/* bit 3 */
#define TXIF      	INTF1bits.TXIF      	/* bit 4 */
#define TXBIF     	INTF1bits.TXBIF     	/* bit 5 */

// ----- IOP0 Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char P00D:1;
		unsigned char P01D:1;
		unsigned char P02D:1;
		unsigned char :1;
		unsigned char :1;
		unsigned char :1;
		unsigned char :1;
		unsigned char :1;
	};
} __IOP0bits_t;
extern volatile __IOP0bits_t __at(IOP0_ADDR) IOP0bits;

#define P00D      	IOP0bits.P00D       	/* bit 0 */
#define P01D      	IOP0bits.P01D       	/* bit 1 */
#define P02D      	IOP0bits.P02D       	/* bit 2 */

// ----- OEP0 Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char P00OE:1;
		unsigned char P01OE:1;
		unsigned char P02OE:1;
		unsigned char :1;
		unsigned char :1;
		unsigned char :1;
		unsigned char :1;
		unsigned char :1;
	};
} __OEP0bits_t;
extern volatile __OEP0bits_t __at(OEP0_ADDR) OEP0bits;

#define P00OE     	OEP0bits.P00OE      	/* bit 0 */
#define P01OE     	OEP0bits.P01OE      	/* bit 1 */
#define P02OE     	OEP0bits.P02OE      	/* bit 2 */

// ----- PUP0 Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char P00PU:1;
		unsigned char P01PU:1;
		unsigned char P02PU:1;
		unsigned char :1;
		unsigned char :1;
		unsigned char :1;
		unsigned char :1;
		unsigned char :1;
	};
} __PUP0bits_t;
extern volatile __PUP0bits_t __at(PUP0_ADDR) PUP0bits;

#define P00PU     	PUP0bits.P00PU      	/* bit 0 */
#define P01PU     	PUP0bits.P01PU      	/* bit 1 */
#define P02PU     	PUP0bits.P02PU      	/* bit 2 */

// ----- PDP0 Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char P00PD:1;
		unsigned char P01PD:1;
		unsigned char P02PD:1;
		unsigned char :1;
		unsigned char :1;
		unsigned char :1;
		unsigned char :1;
		unsigned char :1;
	};
} __PDP0bits_t;
extern volatile __PDP0bits_t __at(PDP0_ADDR) PDP0bits;

#define P00PD     	PDP0bits.P00PD      	/* bit 0 */
#define P01PD     	PDP0bits.P01PD      	/* bit 1 */
#define P02PD     	PDP0bits.P02PD      	/* bit 2 */

// ----- IOP1 Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char P10D:1;
		unsigned char P11D:1;
		unsigned char P12D:1;
		unsigned char P13D:1;
		unsigned char P14D:1;
		unsigned char P15D:1;
		unsigned char :1;
		unsigned char :1;
	};
} __IOP1bits_t;
extern volatile __IOP1bits_t __at(IOP1_ADDR) IOP1bits;

#define P10D      	IOP1bits.P10D       	/* bit 0 */
#define P11D      	IOP1bits.P11D       	/* bit 1 */
#define P12D      	IOP1bits.P12D       	/* bit 2 */
#define P13D      	IOP1bits.P13D       	/* bit 3 */
#define P14D      	IOP1bits.P14D       	/* bit 4 */
#define P15D      	IOP1bits.P15D       	/* bit 5 */

// ----- OEP1 Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char P10OE:1;
		unsigned char P11OE:1;
		unsigned char P12OE:1;
		unsigned char P13OE:1;
		unsigned char P14OE:1;
		unsigned char P15OE:1;
		unsigned char :1;
		unsigned char :1;
	};
} __OEP1bits_t;
extern volatile __OEP1bits_t __at(OEP1_ADDR) OEP1bits;

#define P10OE     	OEP1bits.P10OE      	/* bit 0 */
#define P11OE     	OEP1bits.P11OE      	/* bit 1 */
#define P12OE     	OEP1bits.P12OE      	/* bit 2 */
#define P13OE     	OEP1bits.P13OE      	/* bit 3 */
#define P14OE     	OEP1bits.P14OE      	/* bit 4 */
#define P15OE     	OEP1bits.P15OE      	/* bit 5 */

// ----- PUP1 Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char P10PU:1;
		unsigned char P11PU:1;
		unsigned char P12PU:1;
		unsigned char P13PU:1;
		unsigned char P14PU:1;
		unsigned char P15PU:1;
		unsigned char :1;
		unsigned char :1;
	};
} __PUP1bits_t;
extern volatile __PUP1bits_t __at(PUP1_ADDR) PUP1bits;

#define P10PU     	PUP1bits.P10PU      	/* bit 0 */
#define P11PU     	PUP1bits.P11PU      	/* bit 1 */
#define P12PU     	PUP1bits.P12PU      	/* bit 2 */
#define P13PU     	PUP1bits.P13PU      	/* bit 3 */
#define P14PU     	PUP1bits.P14PU      	/* bit 4 */
#define P15PU     	PUP1bits.P15PU      	/* bit 5 */

// ----- PDP1 Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char P10PD:1;
		unsigned char P11PD:1;
		unsigned char P12PD:1;
		unsigned char P13PD:1;
		unsigned char P14PD:1;
		unsigned char P15PD:1;
		unsigned char :1;
		unsigned char :1;
	};
} __PDP1bits_t;
extern volatile __PDP1bits_t __at(PDP1_ADDR) PDP1bits;

#define P10PD     	PDP1bits.P10PD      	/* bit 0 */
#define P11PD     	PDP1bits.P11PD      	/* bit 1 */
#define P12PD     	PDP1bits.P12PD      	/* bit 2 */
#define P13PD     	PDP1bits.P13PD      	/* bit 3 */
#define P14PD     	PDP1bits.P14PD      	/* bit 4 */
#define P15PD     	PDP1bits.P15PD      	/* bit 5 */

// ----- IOP2 Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char P20D:1;
		unsigned char P21D:1;
		unsigned char P22D:1;
		unsigned char P23D:1;
		unsigned char P24D:1;
		unsigned char P25D:1;
		unsigned char :1;
		unsigned char :1;
	};
} __IOP2bits_t;
extern volatile __IOP2bits_t __at(IOP2_ADDR) IOP2bits;

#define P20D      	IOP2bits.P20D       	/* bit 0 */
#define P21D      	IOP2bits.P21D       	/* bit 1 */
#define P22D      	IOP2bits.P22D       	/* bit 2 */
#define P23D      	IOP2bits.P23D       	/* bit 3 */
#define P24D      	IOP2bits.P24D       	/* bit 4 */
#define P25D      	IOP2bits.P25D       	/* bit 5 */

// ----- OEP2 Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char P20OE:1;
		unsigned char P21OE:1;
		unsigned char P22OE:1;
		unsigned char P23OE:1;
		unsigned char P24OE:1;
		unsigned char P25OE:1;
		unsigned char :1;
		unsigned char :1;
	};
} __OEP2bits_t;
extern volatile __OEP2bits_t __at(OEP2_ADDR) OEP2bits;

#define P20OE     	OEP2bits.P20OE      	/* bit 0 */
#define P21OE     	OEP2bits.P21OE      	/* bit 1 */
#define P22OE     	OEP2bits.P22OE      	/* bit 2 */
#define P23OE     	OEP2bits.P23OE      	/* bit 3 */
#define P24OE     	OEP2bits.P24OE      	/* bit 4 */
#define P25OE     	OEP2bits.P25OE      	/* bit 5 */

// ----- PUP2 Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char P20PU:1;
		unsigned char P21PU:1;
		unsigned char P22PU:1;
		unsigned char P23PU:1;
		unsigned char P24PU:1;
		unsigned char P25PU:1;
		unsigned char :1;
		unsigned char :1;
	};
} __PUP2bits_t;
extern volatile __PUP2bits_t __at(PUP2_ADDR) PUP2bits;

#define P20PU     	PUP2bits.P20PU      	/* bit 0 */
#define P21PU     	PUP2bits.P21PU      	/* bit 1 */
#define P22PU     	PUP2bits.P22PU      	/* bit 2 */
#define P23PU     	PUP2bits.P23PU      	/* bit 3 */
#define P24PU     	PUP2bits.P24PU      	/* bit 4 */
#define P25PU     	PUP2bits.P25PU      	/* bit 5 */

// ----- PDP2 Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char P20PD:1;
		unsigned char P21PD:1;
		unsigned char P22PD:1;
		unsigned char P23PD:1;
		unsigned char P24PD:1;
		unsigned char P25PD:1;
		unsigned char :1;
		unsigned char :1;
	};
} __PDP2bits_t;
extern volatile __PDP2bits_t __at(PDP2_ADDR) PDP2bits;

#define P20PD     	PDP2bits.P20PD      	/* bit 0 */
#define P21PD     	PDP2bits.P21PD      	/* bit 1 */
#define P22PD     	PDP2bits.P22PD      	/* bit 2 */
#define P23PD     	PDP2bits.P23PD      	/* bit 3 */
#define P24PD     	PDP2bits.P24PD      	/* bit 4 */
#define P25PD     	PDP2bits.P25PD      	/* bit 5 */

// ----- P1KBCR Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char P10KE:1;
		unsigned char P11KE:1;
		unsigned char P12KE:1;
		unsigned char P13KE:1;
		unsigned char P14KE:1;
		unsigned char P15KE:1;
		unsigned char :1;
		unsigned char :1;
	};
} __P1KBCRbits_t;
extern volatile __P1KBCRbits_t __at(P1KBCR_ADDR) P1KBCRbits;

#define P10KE     	P1KBCRbits.P10KE    	/* bit 0 */
#define P11KE     	P1KBCRbits.P11KE    	/* bit 1 */
#define P12KE     	P1KBCRbits.P12KE    	/* bit 2 */
#define P13KE     	P1KBCRbits.P13KE    	/* bit 3 */
#define P14KE     	P1KBCRbits.P14KE    	/* bit 4 */
#define P15KE     	P1KBCRbits.P15KE    	/* bit 5 */

// ----- P2KBCR Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char P20KE:1;
		unsigned char P21KE:1;
		unsigned char P22KE:1;
		unsigned char P23KE:1;
		unsigned char P24KE:1;
		unsigned char P25KE:1;
		unsigned char :1;
		unsigned char :1;
	};
} __P2KBCRbits_t;
extern volatile __P2KBCRbits_t __at(P2KBCR_ADDR) P2KBCRbits;

#define P20KE     	P2KBCRbits.P20KE    	/* bit 0 */
#define P21KE     	P2KBCRbits.P21KE    	/* bit 1 */
#define P22KE     	P2KBCRbits.P22KE    	/* bit 2 */
#define P23KE     	P2KBCRbits.P23KE    	/* bit 3 */
#define P24KE     	P2KBCRbits.P24KE    	/* bit 4 */
#define P25KE     	P2KBCRbits.P25KE    	/* bit 5 */

// ----- LVDCR Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char LVDF:1;
		unsigned char :1;
		unsigned char :1;
		unsigned char LVDVS0:1;
		unsigned char LVDVS1:1;
		unsigned char LVDVS2:1;
		unsigned char :1;
		unsigned char LVDEN:1;
	};
} __LVDCRbits_t;
extern volatile __LVDCRbits_t __at(LVDCR_ADDR) LVDCRbits;

#define LVDF      	LVDCRbits.LVDF      	/* bit 0 */
#define LVDVS0    	LVDCRbits.LVDVS0    	/* bit 3 */
#define LVDVS1    	LVDCRbits.LVDVS1    	/* bit 4 */
#define LVDVS2    	LVDCRbits.LVDVS2    	/* bit 5 */
#define LVDEN     	LVDCRbits.LVDEN     	/* bit 7 */

// ----- T0CR Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char T0PRS0:1;
		unsigned char T0PRS1:1;
		unsigned char T0PRS2:1;
		unsigned char T0CKS0:1;
		unsigned char T0CKS1:1;
		unsigned char :1;
		unsigned char :1;
		unsigned char T0EN:1;
	};
} __T0CRbits_t;
extern volatile __T0CRbits_t __at(T0CR_ADDR) T0CRbits;

#define T0PRS0    	T0CRbits.T0PRS0     	/* bit 0 */
#define T0PRS1    	T0CRbits.T0PRS1     	/* bit 1 */
#define T0PRS2    	T0CRbits.T0PRS2     	/* bit 2 */
#define T0CKS0    	T0CRbits.T0CKS0     	/* bit 3 */
#define T0CKS1    	T0CRbits.T0CKS1     	/* bit 4 */
#define T0EN      	T0CRbits.T0EN       	/* bit 7 */

// ----- T0CNT Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char T0CNT0:1;
		unsigned char T0CNT1:1;
		unsigned char T0CNT2:1;
		unsigned char T0CNT3:1;
		unsigned char T0CNT4:1;
		unsigned char T0CNT5:1;
		unsigned char T0CNT6:1;
		unsigned char T0CNT7:1;
	};
} __T0CNTbits_t;
extern volatile __T0CNTbits_t __at(T0CNT_ADDR) T0CNTbits;

#define T0CNT0    	T0CNTbits.T0CNT0    	/* bit 0 */
#define T0CNT1    	T0CNTbits.T0CNT1    	/* bit 1 */
#define T0CNT2    	T0CNTbits.T0CNT2    	/* bit 2 */
#define T0CNT3    	T0CNTbits.T0CNT3    	/* bit 3 */
#define T0CNT4    	T0CNTbits.T0CNT4    	/* bit 4 */
#define T0CNT5    	T0CNTbits.T0CNT5    	/* bit 5 */
#define T0CNT6    	T0CNTbits.T0CNT6    	/* bit 6 */
#define T0CNT7    	T0CNTbits.T0CNT7    	/* bit 7 */

// ----- T0LOAD Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char T0LOAD0:1;
		unsigned char T0LOAD1:1;
		unsigned char T0LOAD2:1;
		unsigned char T0LOAD3:1;
		unsigned char T0LOAD4:1;
		unsigned char T0LOAD5:1;
		unsigned char T0LOAD6:1;
		unsigned char T0LOAD7:1;
	};
} __T0LOADbits_t;
extern volatile __T0LOADbits_t __at(T0LOAD_ADDR) T0LOADbits;

#define T0LOAD0   	T0LOADbits.T0LOAD0  	/* bit 0 */
#define T0LOAD1   	T0LOADbits.T0LOAD1  	/* bit 1 */
#define T0LOAD2   	T0LOADbits.T0LOAD2  	/* bit 2 */
#define T0LOAD3   	T0LOADbits.T0LOAD3  	/* bit 3 */
#define T0LOAD4   	T0LOADbits.T0LOAD4  	/* bit 4 */
#define T0LOAD5   	T0LOADbits.T0LOAD5  	/* bit 5 */
#define T0LOAD6   	T0LOADbits.T0LOAD6  	/* bit 6 */
#define T0LOAD7   	T0LOADbits.T0LOAD7  	/* bit 7 */

// ----- HIRCCAL Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char HIRCCAL0:1;
		unsigned char HIRCCAL1:1;
		unsigned char HIRCCAL2:1;
		unsigned char HIRCCAL3:1;
		unsigned char HIRCCAL4:1;
		unsigned char HIRCCAL5:1;
		unsigned char HIRCCAL6:1;
		unsigned char HIRCCAL7:1;
	};
} __HIRCCALbits_t;
extern volatile __HIRCCALbits_t __at(HIRCCAL_ADDR) HIRCCALbits;

#define HIRCCAL0  	HIRCCALbits.HIRCCAL0	/* bit 0 */
#define HIRCCAL1  	HIRCCALbits.HIRCCAL1	/* bit 1 */
#define HIRCCAL2  	HIRCCALbits.HIRCCAL2	/* bit 2 */
#define HIRCCAL3  	HIRCCALbits.HIRCCAL3	/* bit 3 */
#define HIRCCAL4  	HIRCCALbits.HIRCCAL4	/* bit 4 */
#define HIRCCAL5  	HIRCCALbits.HIRCCAL5	/* bit 5 */
#define HIRCCAL6  	HIRCCALbits.HIRCCAL6	/* bit 6 */
#define HIRCCAL7  	HIRCCALbits.HIRCCAL7	/* bit 7 */

// ----- DBGCR Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char DBG0EN:1;
		unsigned char DBG1EN:1;
		unsigned char :1;
		unsigned char :1;
		unsigned char :1;
		unsigned char :1;
		unsigned char :1;
		unsigned char :1;
	};
} __DBGCRbits_t;
extern volatile __DBGCRbits_t __at(DBGCR_ADDR) DBGCRbits;

#define DBG0EN    	DBGCRbits.DBG0EN    	/* bit 0 */
#define DBG1EN    	DBGCRbits.DBG1EN    	/* bit 1 */

// ----- DBGPR Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char DBGP0:1;
		unsigned char DBGP1:1;
		unsigned char DBGP2:1;
		unsigned char DBGP3:1;
		unsigned char DBGP4:1;
		unsigned char DBGP5:1;
		unsigned char DBGP6:1;
		unsigned char DBGP7:1;
	};
} __DBGPRbits_t;
extern volatile __DBGPRbits_t __at(DBGPR_ADDR) DBGPRbits;

#define DBGP0     	DBGPRbits.DBGP0     	/* bit 0 */
#define DBGP1     	DBGPRbits.DBGP1     	/* bit 1 */
#define DBGP2     	DBGPRbits.DBGP2     	/* bit 2 */
#define DBGP3     	DBGPRbits.DBGP3     	/* bit 3 */
#define DBGP4     	DBGPRbits.DBGP4     	/* bit 4 */
#define DBGP5     	DBGPRbits.DBGP5     	/* bit 5 */
#define DBGP6     	DBGPRbits.DBGP6     	/* bit 6 */
#define DBGP7     	DBGPRbits.DBGP7     	/* bit 7 */

// ----- T1CR0 Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char T1PRS0:1;
		unsigned char T1PRS1:1;
		unsigned char T1PRS2:1;
		unsigned char T1CKS0:1;
		unsigned char T1CKS1:1;
		unsigned char :1;
		unsigned char T1MOD:1;
		unsigned char T1EN:1;
	};
} __T1CR0bits_t;
extern volatile __T1CR0bits_t __at(T1CR0_ADDR) T1CR0bits;

#define T1PRS0    	T1CR0bits.T1PRS0    	/* bit 0 */
#define T1PRS1    	T1CR0bits.T1PRS1    	/* bit 1 */
#define T1PRS2    	T1CR0bits.T1PRS2    	/* bit 2 */
#define T1CKS0    	T1CR0bits.T1CKS0    	/* bit 3 */
#define T1CKS1    	T1CR0bits.T1CKS1    	/* bit 4 */
#define T1MOD     	T1CR0bits.T1MOD     	/* bit 6 */
#define T1EN      	T1CR0bits.T1EN      	/* bit 7 */

// ----- T1CR1 Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char T1CCT0:1;
		unsigned char T1CCT1:1;
		unsigned char T1CSTP:1;
		unsigned char T1CSTR:1;
		unsigned char T1CINS0:1;
		unsigned char T1CINS1:1;
		unsigned char T1CINS2:1;
		unsigned char T1CEOC:1;
	};
} __T1CR1bits_t;
extern volatile __T1CR1bits_t __at(T1CR1_ADDR) T1CR1bits;

#define T1CCT0    	T1CR1bits.T1CCT0    	/* bit 0 */
#define T1CCT1    	T1CR1bits.T1CCT1    	/* bit 1 */
#define T1CSTP    	T1CR1bits.T1CSTP    	/* bit 2 */
#define T1CSTR    	T1CR1bits.T1CSTR    	/* bit 3 */
#define T1CINS0   	T1CR1bits.T1CINS0   	/* bit 4 */
#define T1CINS1   	T1CR1bits.T1CINS1   	/* bit 5 */
#define T1CINS2   	T1CR1bits.T1CINS2   	/* bit 6 */
#define T1CEOC    	T1CR1bits.T1CEOC    	/* bit 7 */

// ----- T1CNTH Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char T1CNT8:1;
		unsigned char T1CNT9:1;
		unsigned char T1CNT10:1;
		unsigned char T1CNT11:1;
		unsigned char T1CNT12:1;
		unsigned char T1CNT13:1;
		unsigned char T1CNT14:1;
		unsigned char T1CNT15:1;
	};
} __T1CNTHbits_t;
extern volatile __T1CNTHbits_t __at(T1CNTH_ADDR) T1CNTHbits;

#define T1CNT8    	T1CNTHbits.T1CNT8   	/* bit 0 */
#define T1CNT9    	T1CNTHbits.T1CNT9   	/* bit 1 */
#define T1CNT10   	T1CNTHbits.T1CNT10  	/* bit 2 */
#define T1CNT11   	T1CNTHbits.T1CNT11  	/* bit 3 */
#define T1CNT12   	T1CNTHbits.T1CNT12  	/* bit 4 */
#define T1CNT13   	T1CNTHbits.T1CNT13  	/* bit 5 */
#define T1CNT14   	T1CNTHbits.T1CNT14  	/* bit 6 */
#define T1CNT15   	T1CNTHbits.T1CNT15  	/* bit 7 */

// ----- T1CNTL Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char T1CNT0:1;
		unsigned char T1CNT1:1;
		unsigned char T1CNT2:1;
		unsigned char T1CNT3:1;
		unsigned char T1CNT4:1;
		unsigned char T1CNT5:1;
		unsigned char T1CNT6:1;
		unsigned char T1CNT7:1;
	};
} __T1CNTLbits_t;
extern volatile __T1CNTLbits_t __at(T1CNTL_ADDR) T1CNTLbits;

#define T1CNT0    	T1CNTLbits.T1CNT0   	/* bit 0 */
#define T1CNT1    	T1CNTLbits.T1CNT1   	/* bit 1 */
#define T1CNT2    	T1CNTLbits.T1CNT2   	/* bit 2 */
#define T1CNT3    	T1CNTLbits.T1CNT3   	/* bit 3 */
#define T1CNT4    	T1CNTLbits.T1CNT4   	/* bit 4 */
#define T1CNT5    	T1CNTLbits.T1CNT5   	/* bit 5 */
#define T1CNT6    	T1CNTLbits.T1CNT6   	/* bit 6 */
#define T1CNT7    	T1CNTLbits.T1CNT7   	/* bit 7 */

// ----- T1LOADH Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char T1LOAD8:1;
		unsigned char T1LOAD9:1;
		unsigned char T1LOAD10:1;
		unsigned char T1LOAD11:1;
		unsigned char T1LOAD12:1;
		unsigned char T1LOAD13:1;
		unsigned char T1LOAD14:1;
		unsigned char T1LOAD15:1;
	};
} __T1LOADHbits_t;
extern volatile __T1LOADHbits_t __at(T1LOADH_ADDR) T1LOADHbits;

#define T1LOAD8   	T1LOADHbits.T1LOAD8 	/* bit 0 */
#define T1LOAD9   	T1LOADHbits.T1LOAD9 	/* bit 1 */
#define T1LOAD10  	T1LOADHbits.T1LOAD10	/* bit 2 */
#define T1LOAD11  	T1LOADHbits.T1LOAD11	/* bit 3 */
#define T1LOAD12  	T1LOADHbits.T1LOAD12	/* bit 4 */
#define T1LOAD13  	T1LOADHbits.T1LOAD13	/* bit 5 */
#define T1LOAD14  	T1LOADHbits.T1LOAD14	/* bit 6 */
#define T1LOAD15  	T1LOADHbits.T1LOAD15	/* bit 7 */

// ----- T1LOADL Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char T1LOAD0:1;
		unsigned char T1LOAD1:1;
		unsigned char T1LOAD2:1;
		unsigned char T1LOAD3:1;
		unsigned char T1LOAD4:1;
		unsigned char T1LOAD5:1;
		unsigned char T1LOAD6:1;
		unsigned char T1LOAD7:1;
	};
} __T1LOADLbits_t;
extern volatile __T1LOADLbits_t __at(T1LOADL_ADDR) T1LOADLbits;

#define T1LOAD0   	T1LOADLbits.T1LOAD0 	/* bit 0 */
#define T1LOAD1   	T1LOADLbits.T1LOAD1 	/* bit 1 */
#define T1LOAD2   	T1LOADLbits.T1LOAD2 	/* bit 2 */
#define T1LOAD3   	T1LOADLbits.T1LOAD3 	/* bit 3 */
#define T1LOAD4   	T1LOADLbits.T1LOAD4 	/* bit 4 */
#define T1LOAD5   	T1LOADLbits.T1LOAD5 	/* bit 5 */
#define T1LOAD6   	T1LOADLbits.T1LOAD6 	/* bit 6 */
#define T1LOAD7   	T1LOADLbits.T1LOAD7 	/* bit 7 */

// ----- T2CR Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char T2PRS0:1;
		unsigned char T2PRS1:1;
		unsigned char T2PRS2:1;
		unsigned char T2CKS0:1;
		unsigned char T2CKS1:1;
		unsigned char FPWM2AEC:1;
		unsigned char PWM2AEC:1;
		unsigned char T2EN:1;
	};
} __T2CRbits_t;
extern volatile __T2CRbits_t __at(T2CR_ADDR) T2CRbits;

#define T2PRS0    	T2CRbits.T2PRS0     	/* bit 0 */
#define T2PRS1    	T2CRbits.T2PRS1     	/* bit 1 */
#define T2PRS2    	T2CRbits.T2PRS2     	/* bit 2 */
#define T2CKS0    	T2CRbits.T2CKS0     	/* bit 3 */
#define T2CKS1    	T2CRbits.T2CKS1     	/* bit 4 */
#define FPWM2AEC  	T2CRbits.FPWM2AEC   	/* bit 5 */
#define PWM2AEC   	T2CRbits.PWM2AEC    	/* bit 6 */
#define T2EN      	T2CRbits.T2EN       	/* bit 7 */

// ----- T2CNT Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char T2CNT0:1;
		unsigned char T2CNT1:1;
		unsigned char T2CNT2:1;
		unsigned char T2CNT3:1;
		unsigned char T2CNT4:1;
		unsigned char T2CNT5:1;
		unsigned char T2CNT6:1;
		unsigned char T2CNT7:1;
	};
} __T2CNTbits_t;
extern volatile __T2CNTbits_t __at(T2CNT_ADDR) T2CNTbits;

#define T2CNT0    	T2CNTbits.T2CNT0    	/* bit 0 */
#define T2CNT1    	T2CNTbits.T2CNT1    	/* bit 1 */
#define T2CNT2    	T2CNTbits.T2CNT2    	/* bit 2 */
#define T2CNT3    	T2CNTbits.T2CNT3    	/* bit 3 */
#define T2CNT4    	T2CNTbits.T2CNT4    	/* bit 4 */
#define T2CNT5    	T2CNTbits.T2CNT5    	/* bit 5 */
#define T2CNT6    	T2CNTbits.T2CNT6    	/* bit 6 */
#define T2CNT7    	T2CNTbits.T2CNT7    	/* bit 7 */

// ----- T2LOAD Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char T2LOAD0:1;
		unsigned char T2LOAD1:1;
		unsigned char T2LOAD2:1;
		unsigned char T2LOAD3:1;
		unsigned char T2LOAD4:1;
		unsigned char T2LOAD5:1;
		unsigned char T2LOAD6:1;
		unsigned char T2LOAD7:1;
	};
} __T2LOADbits_t;
extern volatile __T2LOADbits_t __at(T2LOAD_ADDR) T2LOADbits;

#define T2LOAD0   	T2LOADbits.T2LOAD0  	/* bit 0 */
#define T2LOAD1   	T2LOADbits.T2LOAD1  	/* bit 1 */
#define T2LOAD2   	T2LOADbits.T2LOAD2  	/* bit 2 */
#define T2LOAD3   	T2LOADbits.T2LOAD3  	/* bit 3 */
#define T2LOAD4   	T2LOADbits.T2LOAD4  	/* bit 4 */
#define T2LOAD5   	T2LOADbits.T2LOAD5  	/* bit 5 */
#define T2LOAD6   	T2LOADbits.T2LOAD6  	/* bit 6 */
#define T2LOAD7   	T2LOADbits.T2LOAD7  	/* bit 7 */

// ----- T2DATA Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char T2DATA0:1;
		unsigned char T2DATA1:1;
		unsigned char T2DATA2:1;
		unsigned char T2DATA3:1;
		unsigned char T2DATA4:1;
		unsigned char T2DATA5:1;
		unsigned char T2DATA6:1;
		unsigned char T2DATA7:1;
	};
} __T2DATAbits_t;
extern volatile __T2DATAbits_t __at(T2DATA_ADDR) T2DATAbits;

#define T2DATA0   	T2DATAbits.T2DATA0  	/* bit 0 */
#define T2DATA1   	T2DATAbits.T2DATA1  	/* bit 1 */
#define T2DATA2   	T2DATAbits.T2DATA2  	/* bit 2 */
#define T2DATA3   	T2DATAbits.T2DATA3  	/* bit 3 */
#define T2DATA4   	T2DATAbits.T2DATA4  	/* bit 4 */
#define T2DATA5   	T2DATAbits.T2DATA5  	/* bit 5 */
#define T2DATA6   	T2DATAbits.T2DATA6  	/* bit 6 */
#define T2DATA7   	T2DATAbits.T2DATA7  	/* bit 7 */

// ----- T2DATB Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char T2DATB0:1;
		unsigned char T2DATB1:1;
		unsigned char T2DATB2:1;
		unsigned char T2DATB3:1;
		unsigned char T2DATB4:1;
		unsigned char T2DATB5:1;
		unsigned char T2DATB6:1;
		unsigned char T2DATB7:1;
	};
} __T2DATBbits_t;
extern volatile __T2DATBbits_t __at(T2DATB_ADDR) T2DATBbits;

#define T2DATB0   	T2DATBbits.T2DATB0  	/* bit 0 */
#define T2DATB1   	T2DATBbits.T2DATB1  	/* bit 1 */
#define T2DATB2   	T2DATBbits.T2DATB2  	/* bit 2 */
#define T2DATB3   	T2DATBbits.T2DATB3  	/* bit 3 */
#define T2DATB4   	T2DATBbits.T2DATB4  	/* bit 4 */
#define T2DATB5   	T2DATBbits.T2DATB5  	/* bit 5 */
#define T2DATB6   	T2DATBbits.T2DATB6  	/* bit 6 */
#define T2DATB7   	T2DATBbits.T2DATB7  	/* bit 7 */

// ----- T2DATC Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char T2DATC0:1;
		unsigned char T2DATC1:1;
		unsigned char T2DATC2:1;
		unsigned char T2DATC3:1;
		unsigned char T2DATC4:1;
		unsigned char T2DATC5:1;
		unsigned char T2DATC6:1;
		unsigned char T2DATC7:1;
	};
} __T2DATCbits_t;
extern volatile __T2DATCbits_t __at(T2DATC_ADDR) T2DATCbits;

#define T2DATC0   	T2DATCbits.T2DATC0  	/* bit 0 */
#define T2DATC1   	T2DATCbits.T2DATC1  	/* bit 1 */
#define T2DATC2   	T2DATCbits.T2DATC2  	/* bit 2 */
#define T2DATC3   	T2DATCbits.T2DATC3  	/* bit 3 */
#define T2DATC4   	T2DATCbits.T2DATC4  	/* bit 4 */
#define T2DATC5   	T2DATCbits.T2DATC5  	/* bit 5 */
#define T2DATC6   	T2DATCbits.T2DATC6  	/* bit 6 */
#define T2DATC7   	T2DATCbits.T2DATC7  	/* bit 7 */

// ----- PWM2CR0 Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char PWM2BEC:1;
		unsigned char PWM2CEC:1;
		unsigned char FPWM2ACHS:1;
		unsigned char :1;
		unsigned char FPWM2ANV:1;
		unsigned char PWM2ANV:1;
		unsigned char PWM2BNV:1;
		unsigned char PWM2CNV:1;
	};
} __PWM2CR0bits_t;
extern volatile __PWM2CR0bits_t __at(PWM2CR0_ADDR) PWM2CR0bits;

#define PWM2BEC   	PWM2CR0bits.PWM2BEC 	/* bit 0 */
#define PWM2CEC   	PWM2CR0bits.PWM2CEC 	/* bit 1 */
#define FPWM2ACHS 	PWM2CR0bits.FPWM2ACHS	/* bit 2 */
#define FPWM2ANV  	PWM2CR0bits.FPWM2ANV	/* bit 4 */
#define PWM2ANV   	PWM2CR0bits.PWM2ANV 	/* bit 5 */
#define PWM2BNV   	PWM2CR0bits.PWM2BNV 	/* bit 6 */
#define PWM2CNV   	PWM2CR0bits.PWM2CNV 	/* bit 7 */

// ----- PWM2CR1 Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char FPWM2AE0:1;
		unsigned char FPWM2AE1:1;
		unsigned char FPWM2AE2:1;
		unsigned char FPWM2AE3:1;
		unsigned char FPWM2AE4:1;
		unsigned char FPWM2AE5:1;
		unsigned char :1;
		unsigned char :1;
	};
} __PWM2CR1bits_t;
extern volatile __PWM2CR1bits_t __at(PWM2CR1_ADDR) PWM2CR1bits;

#define FPWM2AE0  	PWM2CR1bits.FPWM2AE0	/* bit 0 */
#define FPWM2AE1  	PWM2CR1bits.FPWM2AE1	/* bit 1 */
#define FPWM2AE2  	PWM2CR1bits.FPWM2AE2	/* bit 2 */
#define FPWM2AE3  	PWM2CR1bits.FPWM2AE3	/* bit 3 */
#define FPWM2AE4  	PWM2CR1bits.FPWM2AE4	/* bit 4 */
#define FPWM2AE5  	PWM2CR1bits.FPWM2AE5	/* bit 5 */

// ----- PWM2CR2 Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char PWM2AD0:1;
		unsigned char PWM2AD1:1;
		unsigned char PWM2AD2:1;
		unsigned char PWM2ADB:1;
		unsigned char :1;
		unsigned char :1;
		unsigned char :1;
		unsigned char :1;
	};
} __PWM2CR2bits_t;
extern volatile __PWM2CR2bits_t __at(PWM2CR2_ADDR) PWM2CR2bits;

#define PWM2AD0   	PWM2CR2bits.PWM2AD0 	/* bit 0 */
#define PWM2AD1   	PWM2CR2bits.PWM2AD1 	/* bit 1 */
#define PWM2AD2   	PWM2CR2bits.PWM2AD2 	/* bit 2 */
#define PWM2ADB   	PWM2CR2bits.PWM2ADB 	/* bit 3 */

// ----- EECR Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char EEWRITE:1;
		unsigned char EEREAD:1;
		unsigned char :1;
		unsigned char :1;
		unsigned char :1;
		unsigned char :1;
		unsigned char :1;
		unsigned char :1;
	};
} __EECRbits_t;
extern volatile __EECRbits_t __at(EECR_ADDR) EECRbits;

#define EEWRITE   	EECRbits.EEWRITE    	/* bit 0 */
#define EEREAD    	EECRbits.EEREAD     	/* bit 1 */

// ----- EEPR Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char EEP0:1;
		unsigned char EEP1:1;
		unsigned char EEP2:1;
		unsigned char EEP3:1;
		unsigned char EEP4:1;
		unsigned char EEP5:1;
		unsigned char EEP6:1;
		unsigned char EEP7:1;
	};
} __EEPRbits_t;
extern volatile __EEPRbits_t __at(EEPR_ADDR) EEPRbits;

#define EEP0      	EEPRbits.EEP0       	/* bit 0 */
#define EEP1      	EEPRbits.EEP1       	/* bit 1 */
#define EEP2      	EEPRbits.EEP2       	/* bit 2 */
#define EEP3      	EEPRbits.EEP3       	/* bit 3 */
#define EEP4      	EEPRbits.EEP4       	/* bit 4 */
#define EEP5      	EEPRbits.EEP5       	/* bit 5 */
#define EEP6      	EEPRbits.EEP6       	/* bit 6 */
#define EEP7      	EEPRbits.EEP7       	/* bit 7 */

// ----- EEAR Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char EEA0:1;
		unsigned char EEA1:1;
		unsigned char EEA2:1;
		unsigned char EEA3:1;
		unsigned char EEA4:1;
		unsigned char EEA5:1;
		unsigned char EEA6:1;
		unsigned char :1;
	};
} __EEARbits_t;
extern volatile __EEARbits_t __at(EEAR_ADDR) EEARbits;

#define EEA0      	EEARbits.EEA0       	/* bit 0 */
#define EEA1      	EEARbits.EEA1       	/* bit 1 */
#define EEA2      	EEARbits.EEA2       	/* bit 2 */
#define EEA3      	EEARbits.EEA3       	/* bit 3 */
#define EEA4      	EEARbits.EEA4       	/* bit 4 */
#define EEA5      	EEARbits.EEA5       	/* bit 5 */
#define EEA6      	EEARbits.EEA6       	/* bit 6 */

// ----- EEDRH Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char EED8:1;
		unsigned char EED9:1;
		unsigned char EED10:1;
		unsigned char EED11:1;
		unsigned char EED12:1;
		unsigned char EED13:1;
		unsigned char EED14:1;
		unsigned char EED15:1;
	};
} __EEDRHbits_t;
extern volatile __EEDRHbits_t __at(EEDRH_ADDR) EEDRHbits;

#define EED8      	EEDRHbits.EED8      	/* bit 0 */
#define EED9      	EEDRHbits.EED9      	/* bit 1 */
#define EED10     	EEDRHbits.EED10     	/* bit 2 */
#define EED11     	EEDRHbits.EED11     	/* bit 3 */
#define EED12     	EEDRHbits.EED12     	/* bit 4 */
#define EED13     	EEDRHbits.EED13     	/* bit 5 */
#define EED14     	EEDRHbits.EED14     	/* bit 6 */
#define EED15     	EEDRHbits.EED15     	/* bit 7 */

// ----- EEDRL Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char EED0:1;
		unsigned char EED1:1;
		unsigned char EED2:1;
		unsigned char EED3:1;
		unsigned char EED4:1;
		unsigned char EED5:1;
		unsigned char EED6:1;
		unsigned char EED7:1;
	};
} __EEDRLbits_t;
extern volatile __EEDRLbits_t __at(EEDRL_ADDR) EEDRLbits;

#define EED0      	EEDRLbits.EED0      	/* bit 0 */
#define EED1      	EEDRLbits.EED1      	/* bit 1 */
#define EED2      	EEDRLbits.EED2      	/* bit 2 */
#define EED3      	EEDRLbits.EED3      	/* bit 3 */
#define EED4      	EEDRLbits.EED4      	/* bit 4 */
#define EED5      	EEDRLbits.EED5      	/* bit 5 */
#define EED6      	EEDRLbits.EED6      	/* bit 6 */
#define EED7      	EEDRLbits.EED7      	/* bit 7 */

// ----- ADCR0 Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char ADCHS0:1;
		unsigned char ADCHS1:1;
		unsigned char ADCHS2:1;
		unsigned char ADCHS3:1;
		unsigned char ADCKS0:1;
		unsigned char ADCKS1:1;
		unsigned char ADEOC:1;
		unsigned char ADEN:1;
	};
} __ADCR0bits_t;
extern volatile __ADCR0bits_t __at(ADCR0_ADDR) ADCR0bits;

#define ADCHS0    	ADCR0bits.ADCHS0    	/* bit 0 */
#define ADCHS1    	ADCR0bits.ADCHS1    	/* bit 1 */
#define ADCHS2    	ADCR0bits.ADCHS2    	/* bit 2 */
#define ADCHS3    	ADCR0bits.ADCHS3    	/* bit 3 */
#define ADCKS0    	ADCR0bits.ADCKS0    	/* bit 4 */
#define ADCKS1    	ADCR0bits.ADCKS1    	/* bit 5 */
#define ADEOC     	ADCR0bits.ADEOC     	/* bit 6 */
#define ADEN      	ADCR0bits.ADEN      	/* bit 7 */

// ----- ADCR1 Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char ADSPS0:1;
		unsigned char ADSPS1:1;
		unsigned char :1;
		unsigned char :1;
		unsigned char ADVRS0:1;
		unsigned char ADVRS1:1;
		unsigned char ADVRS2:1;
		unsigned char ADRSEL:1;
	};
} __ADCR1bits_t;
extern volatile __ADCR1bits_t __at(ADCR1_ADDR) ADCR1bits;

#define ADSPS0    	ADCR1bits.ADSPS0    	/* bit 0 */
#define ADSPS1    	ADCR1bits.ADSPS1    	/* bit 1 */
#define ADVRS0    	ADCR1bits.ADVRS0    	/* bit 4 */
#define ADVRS1    	ADCR1bits.ADVRS1    	/* bit 5 */
#define ADVRS2    	ADCR1bits.ADVRS2    	/* bit 6 */
#define ADRSEL    	ADCR1bits.ADRSEL    	/* bit 7 */

// ----- ADRH Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char ADR4:1;
		unsigned char ADR5:1;
		unsigned char ADR6:1;
		unsigned char ADR7:1;
		unsigned char ADR8:1;
		unsigned char ADR9:1;
		unsigned char ADR10:1;
		unsigned char ADR11:1;
	};
} __ADRHbits_t;
extern volatile __ADRHbits_t __at(ADRH_ADDR) ADRHbits;

#define ADR4      	ADRHbits.ADR4       	/* bit 0 */
#define ADR5      	ADRHbits.ADR5       	/* bit 1 */
#define ADR6      	ADRHbits.ADR6       	/* bit 2 */
#define ADR7      	ADRHbits.ADR7       	/* bit 3 */
#define ADR8      	ADRHbits.ADR8       	/* bit 4 */
#define ADR9      	ADRHbits.ADR9       	/* bit 5 */
#define ADR10     	ADRHbits.ADR10      	/* bit 6 */
#define ADR11     	ADRHbits.ADR11      	/* bit 7 */

// ----- ADRL Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char ADR0:1;
		unsigned char ADR1:1;
		unsigned char ADR2:1;
		unsigned char ADR3:1;
		unsigned char :1;
		unsigned char :1;
		unsigned char :1;
		unsigned char :1;
	};
} __ADRLbits_t;
extern volatile __ADRLbits_t __at(ADRL_ADDR) ADRLbits;

#define ADR0      	ADRLbits.ADR0       	/* bit 0 */
#define ADR1      	ADRLbits.ADR1       	/* bit 1 */
#define ADR2      	ADRLbits.ADR2       	/* bit 2 */
#define ADR3      	ADRLbits.ADR3       	/* bit 3 */

// ----- OSADJCR Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char OSADJT0:1;
		unsigned char OSADJT1:1;
		unsigned char OSADJT2:1;
		unsigned char OSADJT3:1;
		unsigned char OSADJT4:1;
		unsigned char OSADJT5:1;
		unsigned char OSADJTD:1;
		unsigned char OSADJEN:1;
	};
} __OSADJCRbits_t;
extern volatile __OSADJCRbits_t __at(OSADJCR_ADDR) OSADJCRbits;

#define OSADJT0   	OSADJCRbits.OSADJT0 	/* bit 0 */
#define OSADJT1   	OSADJCRbits.OSADJT1 	/* bit 1 */
#define OSADJT2   	OSADJCRbits.OSADJT2 	/* bit 2 */
#define OSADJT3   	OSADJCRbits.OSADJT3 	/* bit 3 */
#define OSADJT4   	OSADJCRbits.OSADJT4 	/* bit 4 */
#define OSADJT5   	OSADJCRbits.OSADJT5 	/* bit 5 */
#define OSADJTD   	OSADJCRbits.OSADJTD 	/* bit 6 */
#define OSADJEN   	OSADJCRbits.OSADJEN 	/* bit 7 */

// ----- P0ADCR Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char P00DC:1;
		unsigned char P01DC:1;
		unsigned char P02DC:1;
		unsigned char :1;
		unsigned char :1;
		unsigned char :1;
		unsigned char :1;
		unsigned char :1;
	};
} __P0ADCRbits_t;
extern volatile __P0ADCRbits_t __at(P0ADCR_ADDR) P0ADCRbits;

#define P00DC     	P0ADCRbits.P00DC    	/* bit 0 */
#define P01DC     	P0ADCRbits.P01DC    	/* bit 1 */
#define P02DC     	P0ADCRbits.P02DC    	/* bit 2 */

// ----- P1ADCR Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char P10DC:1;
		unsigned char P11DC:1;
		unsigned char P12DC:1;
		unsigned char P13DC:1;
		unsigned char P14DC:1;
		unsigned char P15DC:1;
		unsigned char :1;
		unsigned char :1;
	};
} __P1ADCRbits_t;
extern volatile __P1ADCRbits_t __at(P1ADCR_ADDR) P1ADCRbits;

#define P10DC     	P1ADCRbits.P10DC    	/* bit 0 */
#define P11DC     	P1ADCRbits.P11DC    	/* bit 1 */
#define P12DC     	P1ADCRbits.P12DC    	/* bit 2 */
#define P13DC     	P1ADCRbits.P13DC    	/* bit 3 */
#define P14DC     	P1ADCRbits.P14DC    	/* bit 4 */
#define P15DC     	P1ADCRbits.P15DC    	/* bit 5 */

// ----- P2ADCR Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char P20DC:1;
		unsigned char P21DC:1;
		unsigned char P22DC:1;
		unsigned char P23DC:1;
		unsigned char P24DC:1;
		unsigned char P25DC:1;
		unsigned char :1;
		unsigned char :1;
	};
} __P2ADCRbits_t;
extern volatile __P2ADCRbits_t __at(P2ADCR_ADDR) P2ADCRbits;

#define P20DC     	P2ADCRbits.P20DC    	/* bit 0 */
#define P21DC     	P2ADCRbits.P21DC    	/* bit 1 */
#define P22DC     	P2ADCRbits.P22DC    	/* bit 2 */
#define P23DC     	P2ADCRbits.P23DC    	/* bit 3 */
#define P24DC     	P2ADCRbits.P24DC    	/* bit 4 */
#define P25DC     	P2ADCRbits.P25DC    	/* bit 5 */

// ----- OPCR0 Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char OP1PS0:1;
		unsigned char OP1PS1:1;
		unsigned char DAC1EN:1;
		unsigned char OP1EN:1;
		unsigned char OP0PS0:1;
		unsigned char OP0PS1:1;
		unsigned char DAC0EN:1;
		unsigned char OP0EN:1;
	};
} __OPCR0bits_t;
extern volatile __OPCR0bits_t __at(OPCR0_ADDR) OPCR0bits;

#define OP1PS0    	OPCR0bits.OP1PS0    	/* bit 0 */
#define OP1PS1    	OPCR0bits.OP1PS1    	/* bit 1 */
#define DAC1EN    	OPCR0bits.DAC1EN    	/* bit 2 */
#define OP1EN     	OPCR0bits.OP1EN     	/* bit 3 */
#define OP0PS0    	OPCR0bits.OP0PS0    	/* bit 4 */
#define OP0PS1    	OPCR0bits.OP0PS1    	/* bit 5 */
#define DAC0EN    	OPCR0bits.DAC0EN    	/* bit 6 */
#define OP0EN     	OPCR0bits.OP0EN     	/* bit 7 */

// ----- OPCR1 Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char OP2OE:1;
		unsigned char :1;
		unsigned char :1;
		unsigned char OP2NS0:1;
		unsigned char OP2NS1:1;
		unsigned char OP2PS:1;
		unsigned char OP2MD:1;
		unsigned char OP2EN:1;
	};
} __OPCR1bits_t;
extern volatile __OPCR1bits_t __at(OPCR1_ADDR) OPCR1bits;

#define OP2OE     	OPCR1bits.OP2OE     	/* bit 0 */
#define OP2NS0    	OPCR1bits.OP2NS0    	/* bit 3 */
#define OP2NS1    	OPCR1bits.OP2NS1    	/* bit 4 */
#define OP2PS     	OPCR1bits.OP2PS     	/* bit 5 */
#define OP2MD     	OPCR1bits.OP2MD     	/* bit 6 */
#define OP2EN     	OPCR1bits.OP2EN     	/* bit 7 */

// ----- OPCR2 Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char OP2OF:1;
		unsigned char OP2IM:1;
		unsigned char OP2NV:1;
		unsigned char OP2DB0:1;
		unsigned char OP2DB1:1;
		unsigned char OP2DB2:1;
		unsigned char OP2AF:1;
		unsigned char :1;
	};
} __OPCR2bits_t;
extern volatile __OPCR2bits_t __at(OPCR2_ADDR) OPCR2bits;

#define OP2OF     	OPCR2bits.OP2OF     	/* bit 0 */
#define OP2IM     	OPCR2bits.OP2IM     	/* bit 1 */
#define OP2NV     	OPCR2bits.OP2NV     	/* bit 2 */
#define OP2DB0    	OPCR2bits.OP2DB0    	/* bit 3 */
#define OP2DB1    	OPCR2bits.OP2DB1    	/* bit 4 */
#define OP2DB2    	OPCR2bits.OP2DB2    	/* bit 5 */
#define OP2AF     	OPCR2bits.OP2AF     	/* bit 6 */

// ----- OP0VRH Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char OP0PVS8:1;
		unsigned char OP0PVS9:1;
		unsigned char OP0PVS10:1;
		unsigned char OP0PVS11:1;
		unsigned char OP0PVS12:1;
		unsigned char OP0PVS13:1;
		unsigned char :1;
		unsigned char :1;
	};
} __OP0VRHbits_t;
extern volatile __OP0VRHbits_t __at(OP0VRH_ADDR) OP0VRHbits;

#define OP0PVS8   	OP0VRHbits.OP0PVS8  	/* bit 0 */
#define OP0PVS9   	OP0VRHbits.OP0PVS9  	/* bit 1 */
#define OP0PVS10  	OP0VRHbits.OP0PVS10 	/* bit 2 */
#define OP0PVS11  	OP0VRHbits.OP0PVS11 	/* bit 3 */
#define OP0PVS12  	OP0VRHbits.OP0PVS12 	/* bit 4 */
#define OP0PVS13  	OP0VRHbits.OP0PVS13 	/* bit 5 */

// ----- OP0VRL Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char OP0PVS0:1;
		unsigned char OP0PVS1:1;
		unsigned char OP0PVS2:1;
		unsigned char OP0PVS3:1;
		unsigned char OP0PVS4:1;
		unsigned char OP0PVS5:1;
		unsigned char OP0PVS6:1;
		unsigned char OP0PVS7:1;
	};
} __OP0VRLbits_t;
extern volatile __OP0VRLbits_t __at(OP0VRL_ADDR) OP0VRLbits;

#define OP0PVS0   	OP0VRLbits.OP0PVS0  	/* bit 0 */
#define OP0PVS1   	OP0VRLbits.OP0PVS1  	/* bit 1 */
#define OP0PVS2   	OP0VRLbits.OP0PVS2  	/* bit 2 */
#define OP0PVS3   	OP0VRLbits.OP0PVS3  	/* bit 3 */
#define OP0PVS4   	OP0VRLbits.OP0PVS4  	/* bit 4 */
#define OP0PVS5   	OP0VRLbits.OP0PVS5  	/* bit 5 */
#define OP0PVS6   	OP0VRLbits.OP0PVS6  	/* bit 6 */
#define OP0PVS7   	OP0VRLbits.OP0PVS7  	/* bit 7 */

// ----- OP1VRH Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char OP1PVS8:1;
		unsigned char OP1PVS9:1;
		unsigned char OP1PVS10:1;
		unsigned char OP1PVS11:1;
		unsigned char :1;
		unsigned char :1;
		unsigned char :1;
		unsigned char :1;
	};
} __OP1VRHbits_t;
extern volatile __OP1VRHbits_t __at(OP1VRH_ADDR) OP1VRHbits;

#define OP1PVS8   	OP1VRHbits.OP1PVS8  	/* bit 0 */
#define OP1PVS9   	OP1VRHbits.OP1PVS9  	/* bit 1 */
#define OP1PVS10  	OP1VRHbits.OP1PVS10 	/* bit 2 */
#define OP1PVS11  	OP1VRHbits.OP1PVS11 	/* bit 3 */

// ----- OP1VRL Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char OP1PVS0:1;
		unsigned char OP1PVS1:1;
		unsigned char OP1PVS2:1;
		unsigned char OP1PVS3:1;
		unsigned char OP1PVS4:1;
		unsigned char OP1PVS5:1;
		unsigned char OP1PVS6:1;
		unsigned char OP1PVS7:1;
	};
} __OP1VRLbits_t;
extern volatile __OP1VRLbits_t __at(OP1VRL_ADDR) OP1VRLbits;

#define OP1PVS0   	OP1VRLbits.OP1PVS0  	/* bit 0 */
#define OP1PVS1   	OP1VRLbits.OP1PVS1  	/* bit 1 */
#define OP1PVS2   	OP1VRLbits.OP1PVS2  	/* bit 2 */
#define OP1PVS3   	OP1VRLbits.OP1PVS3  	/* bit 3 */
#define OP1PVS4   	OP1VRLbits.OP1PVS4  	/* bit 4 */
#define OP1PVS5   	OP1VRLbits.OP1PVS5  	/* bit 5 */
#define OP1PVS6   	OP1VRLbits.OP1PVS6  	/* bit 6 */
#define OP1PVS7   	OP1VRLbits.OP1PVS7  	/* bit 7 */

// ----- OP2CLR Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char OP2CLR0:1;
		unsigned char OP2CLR1:1;
		unsigned char OP2CLR2:1;
		unsigned char OP2CLR3:1;
		unsigned char OP2CLR4:1;
		unsigned char OP2CLR5:1;
		unsigned char OP2CLRS:1;
		unsigned char OP2CLRE:1;
	};
} __OP2CLRbits_t;
extern volatile __OP2CLRbits_t __at(OP2CLR_ADDR) OP2CLRbits;

#define OP2CLR0   	OP2CLRbits.OP2CLR0  	/* bit 0 */
#define OP2CLR1   	OP2CLRbits.OP2CLR1  	/* bit 1 */
#define OP2CLR2   	OP2CLRbits.OP2CLR2  	/* bit 2 */
#define OP2CLR3   	OP2CLRbits.OP2CLR3  	/* bit 3 */
#define OP2CLR4   	OP2CLRbits.OP2CLR4  	/* bit 4 */
#define OP2CLR5   	OP2CLRbits.OP2CLR5  	/* bit 5 */
#define OP2CLRS   	OP2CLRbits.OP2CLRS  	/* bit 6 */
#define OP2CLRE   	OP2CLRbits.OP2CLRE  	/* bit 7 */

// ----- URTCR0 Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char URTPRS0:1;
		unsigned char URTPRS1:1;
		unsigned char URTPRS2:1;
		unsigned char :1;
		unsigned char UPMD:1;
		unsigned char UPEN:1;
		unsigned char UREN:1;
		unsigned char URTEN:1;
	};
} __URTCR0bits_t;
extern volatile __URTCR0bits_t __at(URTCR0_ADDR) URTCR0bits;

#define URTPRS0   	URTCR0bits.URTPRS0  	/* bit 0 */
#define URTPRS1   	URTCR0bits.URTPRS1  	/* bit 1 */
#define URTPRS2   	URTCR0bits.URTPRS2  	/* bit 2 */
#define UPMD      	URTCR0bits.UPMD     	/* bit 4 */
#define UPEN      	URTCR0bits.UPEN     	/* bit 5 */
#define UREN      	URTCR0bits.UREN     	/* bit 6 */
#define URTEN     	URTCR0bits.URTEN    	/* bit 7 */

// ----- URTCR1 Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char TXB8:1;
		unsigned char USTPF:1;
		unsigned char UDATF:1;
		unsigned char UAEN:1;
		unsigned char :1;
		unsigned char :1;
		unsigned char :1;
		unsigned char :1;
	};
} __URTCR1bits_t;
extern volatile __URTCR1bits_t __at(URTCR1_ADDR) URTCR1bits;

#define TXB8      	URTCR1bits.TXB8     	/* bit 0 */
#define USTPF     	URTCR1bits.USTPF    	/* bit 1 */
#define UDATF     	URTCR1bits.UDATF    	/* bit 2 */
#define UAEN      	URTCR1bits.UAEN     	/* bit 3 */

// ----- URTCR2 Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char URTLNV:1;
		unsigned char URTMOD:1;
		unsigned char URTPTS:1;
		unsigned char URTCHS:1;
		unsigned char :1;
		unsigned char :1;
		unsigned char :1;
		unsigned char :1;
	};
} __URTCR2bits_t;
extern volatile __URTCR2bits_t __at(URTCR2_ADDR) URTCR2bits;

#define URTLNV    	URTCR2bits.URTLNV   	/* bit 0 */
#define URTMOD    	URTCR2bits.URTMOD   	/* bit 1 */
#define URTPTS    	URTCR2bits.URTPTS   	/* bit 2 */
#define URTCHS    	URTCR2bits.URTCHS   	/* bit 3 */

// ----- URTSR Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char RXB8:1;
		unsigned char RXOV:1;
		unsigned char PERR:1;
		unsigned char FERR:1;
		unsigned char :1;
		unsigned char :1;
		unsigned char :1;
		unsigned char TXCL:1;
	};
} __URTSRbits_t;
extern volatile __URTSRbits_t __at(URTSR_ADDR) URTSRbits;

#define RXB8      	URTSRbits.RXB8      	/* bit 0 */
#define RXOV      	URTSRbits.RXOV      	/* bit 1 */
#define PERR      	URTSRbits.PERR      	/* bit 2 */
#define FERR      	URTSRbits.FERR      	/* bit 3 */
#define TXCL      	URTSRbits.TXCL      	/* bit 7 */

// ----- URTBR Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char URTB0:1;
		unsigned char URTB1:1;
		unsigned char URTB2:1;
		unsigned char URTB3:1;
		unsigned char URTB4:1;
		unsigned char URTB5:1;
		unsigned char URTB6:1;
		unsigned char URTB7:1;
	};
} __URTBRbits_t;
extern volatile __URTBRbits_t __at(URTBR_ADDR) URTBRbits;

#define URTB0     	URTBRbits.URTB0     	/* bit 0 */
#define URTB1     	URTBRbits.URTB1     	/* bit 1 */
#define URTB2     	URTBRbits.URTB2     	/* bit 2 */
#define URTB3     	URTBRbits.URTB3     	/* bit 3 */
#define URTB4     	URTBRbits.URTB4     	/* bit 4 */
#define URTB5     	URTBRbits.URTB5     	/* bit 5 */
#define URTB6     	URTBRbits.URTB6     	/* bit 6 */
#define URTB7     	URTBRbits.URTB7     	/* bit 7 */

// ----- URTDR Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char URTD0:1;
		unsigned char URTD1:1;
		unsigned char URTD2:1;
		unsigned char URTD3:1;
		unsigned char URTD4:1;
		unsigned char URTD5:1;
		unsigned char URTD6:1;
		unsigned char URTD7:1;
	};
} __URTDRbits_t;
extern volatile __URTDRbits_t __at(URTDR_ADDR) URTDRbits;

#define URTD0     	URTDRbits.URTD0     	/* bit 0 */
#define URTD1     	URTDRbits.URTD1     	/* bit 1 */
#define URTD2     	URTDRbits.URTD2     	/* bit 2 */
#define URTD3     	URTDRbits.URTD3     	/* bit 3 */
#define URTD4     	URTDRbits.URTD4     	/* bit 4 */
#define URTD5     	URTDRbits.URTD5     	/* bit 5 */
#define URTD6     	URTDRbits.URTD6     	/* bit 6 */
#define URTD7     	URTDRbits.URTD7     	/* bit 7 */

// ----- URTAR Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char URTA0:1;
		unsigned char URTA1:1;
		unsigned char URTA2:1;
		unsigned char URTA3:1;
		unsigned char URTA4:1;
		unsigned char URTA5:1;
		unsigned char URTA6:1;
		unsigned char URTA7:1;
	};
} __URTARbits_t;
extern volatile __URTARbits_t __at(URTAR_ADDR) URTARbits;

#define URTA0     	URTARbits.URTA0     	/* bit 0 */
#define URTA1     	URTARbits.URTA1     	/* bit 1 */
#define URTA2     	URTARbits.URTA2     	/* bit 2 */
#define URTA3     	URTARbits.URTA3     	/* bit 3 */
#define URTA4     	URTARbits.URTA4     	/* bit 4 */
#define URTA5     	URTARbits.URTA5     	/* bit 5 */
#define URTA6     	URTARbits.URTA6     	/* bit 6 */
#define URTA7     	URTARbits.URTA7     	/* bit 7 */

// ----- URTMR Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char URTM0:1;
		unsigned char URTM1:1;
		unsigned char URTM2:1;
		unsigned char URTM3:1;
		unsigned char URTM4:1;
		unsigned char URTM5:1;
		unsigned char URTM6:1;
		unsigned char URTM7:1;
	};
} __URTMRbits_t;
extern volatile __URTMRbits_t __at(URTMR_ADDR) URTMRbits;

#define URTM0     	URTMRbits.URTM0     	/* bit 0 */
#define URTM1     	URTMRbits.URTM1     	/* bit 1 */
#define URTM2     	URTMRbits.URTM2     	/* bit 2 */
#define URTM3     	URTMRbits.URTM3     	/* bit 3 */
#define URTM4     	URTMRbits.URTM4     	/* bit 4 */
#define URTM5     	URTMRbits.URTM5     	/* bit 5 */
#define URTM6     	URTMRbits.URTM6     	/* bit 6 */
#define URTM7     	URTMRbits.URTM7     	/* bit 7 */

#endif
