#ifndef MC32P7132_H
#define MC32P7132_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      	0x018D
#define INTF1_ADDR      	0x018E
#define LVDCR_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 PWM0CR0_ADDR    	0x019C
#define PWM0CR1_ADDR    	0x019D
#define PWM0CR2_ADDR    	0x019E
#define T0CR_ADDR       	0x01A0
#define T0CNT_ADDR      	0x01A1
#define T0LOAD_ADDR     	0x01A2
#define T0DATA_ADDR     	0x01A3
#define T1CR_ADDR       	0x01A5
#define T1CNT_ADDR      	0x01A6
#define T1LOAD_ADDR     	0x01A7
#define T2CR_ADDR       	0x01A8
#define T2CNT_ADDR      	0x01A9
#define T2LOAD_ADDR     	0x01AA
#define T2EFR_ADDR      	0x01AC
#define T3CR_ADDR       	0x01AD
#define T3CNT_ADDR      	0x01AE
#define T3LOAD_ADDR     	0x01AF
#define IICCR_ADDR      	0x01B0
#define IICAR_ADDR      	0x01B1
#define IICDR_ADDR      	0x01B2
#define EEDRH_ADDR      	0x01B3
#define EECR_ADDR       	0x01B4
#define EEMASK_ADDR     	0x01B5
#define EEAR_ADDR       	0x01B6
#define EEDRL_ADDR      	0x01B7
#define ADCR0_ADDR      	0x01B8
#define ADCR1_ADDR      	0x01B9
#define ADRH_ADDR       	0x01BA
#define ADRL_ADDR       	0x01BB
#define P0ADCR_ADDR     	0x01BC
#define P1ADCR_ADDR     	0x01BD
#define OSADJCR_ADDR    	0x01BE
#define MEFCR_ADDR      	0x01BF
#define PPGCR_ADDR      	0x01C0
#define PPGLDH_ADDR     	0x01C1
#define PPGLDL_ADDR     	0x01C2
#define PPGTDL_ADDR     	0x01C3
#define PPGTDB_ADDR     	0x01C4
#define OPACR_ADDR      	0x01C5
#define OPACLR_ADDR     	0x01C6
#define CPCR0_ADDR      	0x01C8
#define CPSR_ADDR       	0x01C9
#define CPVR0_ADDR      	0x01CA
#define CPVR1_ADDR      	0x01CB
#define CP0CLR_ADDR     	0x01CC
#define CP1CLR_ADDR     	0x01CD
#define CP2CLR_ADDR     	0x01CE
#define CP3CLR_ADDR     	0x01CF
#define CPCR1_ADDR      	0x01D0
#define CPCR2_ADDR      	0x01D1
#define CPDB0_ADDR      	0x01D2
#define CPDB1_ADDR      	0x01D3
#define DBGCR_ADDR      	0x01D6
#define DBGPR_ADDR      	0x01D7

//----- 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 (LVDCR_ADDR)    	LVDCR;
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 (PWM0CR0_ADDR)  	PWM0CR0;
extern __sfr __at (PWM0CR1_ADDR)  	PWM0CR1;
extern __sfr __at (PWM0CR2_ADDR)  	PWM0CR2;
extern __sfr __at (T0CR_ADDR)     	T0CR;
extern __sfr __at (T0CNT_ADDR)    	T0CNT;
extern __sfr __at (T0LOAD_ADDR)   	T0LOAD;
extern __sfr __at (T0DATA_ADDR)   	T0DATA;
extern __sfr __at (T1CR_ADDR)     	T1CR;
extern __sfr __at (T1CNT_ADDR)    	T1CNT;
extern __sfr __at (T1LOAD_ADDR)   	T1LOAD;
extern __sfr __at (T2CR_ADDR)     	T2CR;
extern __sfr __at (T2CNT_ADDR)    	T2CNT;
extern __sfr __at (T2LOAD_ADDR)   	T2LOAD;
extern __sfr __at (T2EFR_ADDR)    	T2EFR;
extern __sfr __at (T3CR_ADDR)     	T3CR;
extern __sfr __at (T3CNT_ADDR)    	T3CNT;
extern __sfr __at (T3LOAD_ADDR)   	T3LOAD;
extern __sfr __at (IICCR_ADDR)    	IICCR;
extern __sfr __at (IICAR_ADDR)    	IICAR;
extern __sfr __at (IICDR_ADDR)    	IICDR;
extern __sfr __at (EEDRH_ADDR)    	EEDRH;
extern __sfr __at (EECR_ADDR)     	EECR;
extern __sfr __at (EEMASK_ADDR)   	EEMASK;
extern __sfr __at (EEAR_ADDR)     	EEAR;
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 (P0ADCR_ADDR)   	P0ADCR;
extern __sfr __at (P1ADCR_ADDR)   	P1ADCR;
extern __sfr __at (OSADJCR_ADDR)  	OSADJCR;
extern __sfr __at (MEFCR_ADDR)    	MEFCR;
extern __sfr __at (PPGCR_ADDR)    	PPGCR;
extern __sfr __at (PPGLDH_ADDR)   	PPGLDH;
extern __sfr __at (PPGLDL_ADDR)   	PPGLDL;
extern __sfr __at (PPGTDL_ADDR)   	PPGTDL;
extern __sfr __at (PPGTDB_ADDR)   	PPGTDB;
extern __sfr __at (OPACR_ADDR)    	OPACR;
extern __sfr __at (OPACLR_ADDR)   	OPACLR;
extern __sfr __at (CPCR0_ADDR)    	CPCR0;
extern __sfr __at (CPSR_ADDR)     	CPSR;
extern __sfr __at (CPVR0_ADDR)    	CPVR0;
extern __sfr __at (CPVR1_ADDR)    	CPVR1;
extern __sfr __at (CP0CLR_ADDR)   	CP0CLR;
extern __sfr __at (CP1CLR_ADDR)   	CP1CLR;
extern __sfr __at (CP2CLR_ADDR)   	CP2CLR;
extern __sfr __at (CP3CLR_ADDR)   	CP3CLR;
extern __sfr __at (CPCR1_ADDR)    	CPCR1;
extern __sfr __at (CPCR2_ADDR)    	CPCR2;
extern __sfr __at (CPDB0_ADDR)    	CPDB0;
extern __sfr __at (CPDB1_ADDR)    	CPDB1;
extern __sfr __at (DBGCR_ADDR)    	DBGCR;
extern __sfr __at (DBGPR_ADDR)    	DBGPR;

//==========================================================================
//
//	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 LVDIE:1;
		unsigned char IICIE:1;
		unsigned char ADIE:1;
		unsigned char PPGTIE: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 LVDIE     	INTE0bits.LVDIE     	/* bit 4 */
#define IICIE     	INTE0bits.IICIE     	/* bit 5 */
#define ADIE      	INTE0bits.ADIE      	/* bit 6 */
#define PPGTIE    	INTE0bits.PPGTIE    	/* 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 LVDIF:1;
		unsigned char IICIF:1;
		unsigned char ADIF:1;
		unsigned char PPGTIF: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 LVDIF     	INTF0bits.LVDIF     	/* bit 4 */
#define IICIF     	INTF0bits.IICIF     	/* bit 5 */
#define ADIF      	INTF0bits.ADIF      	/* bit 6 */
#define PPGTIF    	INTF0bits.PPGTIF    	/* 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 T2IE:1;
		unsigned char T3IE:1;
		unsigned char T2PIE:1;
		unsigned char :1;
		unsigned char :1;
		unsigned char CP1IE:1;
		unsigned char CP2IE:1;
		unsigned char CP3IE:1;
	};
} __INTE1bits_t;
extern volatile __INTE1bits_t __at(INTE1_ADDR) INTE1bits;

#define T2IE      	INTE1bits.T2IE      	/* bit 0 */
#define T3IE      	INTE1bits.T3IE      	/* bit 1 */
#define T2PIE     	INTE1bits.T2PIE     	/* bit 2 */
#define CP1IE     	INTE1bits.CP1IE     	/* bit 5 */
#define CP2IE     	INTE1bits.CP2IE     	/* bit 6 */
#define CP3IE     	INTE1bits.CP3IE     	/* bit 7 */

// ----- INTF1 Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char T2IF:1;
		unsigned char T3IF:1;
		unsigned char T2PIF:1;
		unsigned char :1;
		unsigned char :1;
		unsigned char CP1IF:1;
		unsigned char CP2IF:1;
		unsigned char CP3IF:1;
	};
} __INTF1bits_t;
extern volatile __INTF1bits_t __at(INTF1_ADDR) INTF1bits;

#define T2IF      	INTF1bits.T2IF      	/* bit 0 */
#define T3IF      	INTF1bits.T3IF      	/* bit 1 */
#define T2PIF     	INTF1bits.T2PIF     	/* bit 2 */
#define CP1IF     	INTF1bits.CP1IF     	/* bit 5 */
#define CP2IF     	INTF1bits.CP2IF     	/* bit 6 */
#define CP3IF     	INTF1bits.CP3IF     	/* bit 7 */

// ----- LVDCR Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char LVDF:1;
		unsigned char :1;
		unsigned char :1;
		unsigned char :1;
		unsigned char LVDVS:1;
		unsigned char :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 LVDVS     	LVDCRbits.LVDVS     	/* bit 4 */
#define LVDEN     	LVDCRbits.LVDEN     	/* bit 7 */

// ----- IOP0 Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char P00D:1;
		unsigned char P01D:1;
		unsigned char P02D:1;
		unsigned char P03D:1;
		unsigned char P04D:1;
		unsigned char P05D:1;
		unsigned char P06D:1;
		unsigned char P07D: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 */
#define P03D      	IOP0bits.P03D       	/* bit 3 */
#define P04D      	IOP0bits.P04D       	/* bit 4 */
#define P05D      	IOP0bits.P05D       	/* bit 5 */
#define P06D      	IOP0bits.P06D       	/* bit 6 */
#define P07D      	IOP0bits.P07D       	/* bit 7 */

// ----- OEP0 Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char P00OE:1;
		unsigned char P01OE:1;
		unsigned char P02OE:1;
		unsigned char P03OE:1;
		unsigned char P04OE:1;
		unsigned char P05OE:1;
		unsigned char P06OE:1;
		unsigned char P07OE: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 */
#define P03OE     	OEP0bits.P03OE      	/* bit 3 */
#define P04OE     	OEP0bits.P04OE      	/* bit 4 */
#define P05OE     	OEP0bits.P05OE      	/* bit 5 */
#define P06OE     	OEP0bits.P06OE      	/* bit 6 */
#define P07OE     	OEP0bits.P07OE      	/* bit 7 */

// ----- PUP0 Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char P00PU:1;
		unsigned char P01PU:1;
		unsigned char P02PU:1;
		unsigned char P03PU:1;
		unsigned char P04PU:1;
		unsigned char P05PU:1;
		unsigned char P06PU:1;
		unsigned char P07PU: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 */
#define P03PU     	PUP0bits.P03PU      	/* bit 3 */
#define P04PU     	PUP0bits.P04PU      	/* bit 4 */
#define P05PU     	PUP0bits.P05PU      	/* bit 5 */
#define P06PU     	PUP0bits.P06PU      	/* bit 6 */
#define P07PU     	PUP0bits.P07PU      	/* bit 7 */

// ----- PDP0 Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char P00PD:1;
		unsigned char P01PD:1;
		unsigned char P02PD:1;
		unsigned char P03PD:1;
		unsigned char P04PD:1;
		unsigned char P05PD:1;
		unsigned char P06PD:1;
		unsigned char P07PD: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 */
#define P03PD     	PDP0bits.P03PD      	/* bit 3 */
#define P04PD     	PDP0bits.P04PD      	/* bit 4 */
#define P05PD     	PDP0bits.P05PD      	/* bit 5 */
#define P06PD     	PDP0bits.P06PD      	/* bit 6 */
#define P07PD     	PDP0bits.P07PD      	/* bit 7 */

// ----- 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 P16D:1;
		unsigned char P17D: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 */
#define P16D      	IOP1bits.P16D       	/* bit 6 */
#define P17D      	IOP1bits.P17D       	/* bit 7 */

// ----- 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 P16OE:1;
		unsigned char P17OE: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 */
#define P16OE     	OEP1bits.P16OE      	/* bit 6 */
#define P17OE     	OEP1bits.P17OE      	/* bit 7 */

// ----- 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 P16PU:1;
		unsigned char P17PU: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 */
#define P16PU     	PUP1bits.P16PU      	/* bit 6 */
#define P17PU     	PUP1bits.P17PU      	/* bit 7 */

// ----- 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 P16PD:1;
		unsigned char P17PD: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 */
#define P16PD     	PDP1bits.P16PD      	/* bit 6 */
#define P17PD     	PDP1bits.P17PD      	/* bit 7 */

// ----- IOP2 Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char P20D:1;
		unsigned char P21D:1;
		unsigned char :1;
		unsigned char :1;
		unsigned char :1;
		unsigned char :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 */

// ----- OEP2 Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char P20OE:1;
		unsigned char P21OE:1;
		unsigned char :1;
		unsigned char :1;
		unsigned char :1;
		unsigned char :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 */

// ----- PUP2 Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char P20PU:1;
		unsigned char P21PU:1;
		unsigned char :1;
		unsigned char :1;
		unsigned char :1;
		unsigned char :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 */

// ----- PDP2 Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char P20PD:1;
		unsigned char P21PD:1;
		unsigned char :1;
		unsigned char :1;
		unsigned char :1;
		unsigned char :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 */

// ----- PWM0CR0 Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char PWM0OE:1;
		unsigned char PWM0NV:1;
		unsigned char FPWM0OE:1;
		unsigned char FPWM0NV:1;
		unsigned char :1;
		unsigned char :1;
		unsigned char :1;
		unsigned char :1;
	};
} __PWM0CR0bits_t;
extern volatile __PWM0CR0bits_t __at(PWM0CR0_ADDR) PWM0CR0bits;

#define PWM0OE    	PWM0CR0bits.PWM0OE  	/* bit 0 */
#define PWM0NV    	PWM0CR0bits.PWM0NV  	/* bit 1 */
#define FPWM0OE   	PWM0CR0bits.FPWM0OE 	/* bit 2 */
#define FPWM0NV   	PWM0CR0bits.FPWM0NV 	/* bit 3 */

// ----- PWM0CR1 Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char FPWM0E0:1;
		unsigned char FPWM0E1:1;
		unsigned char FPWM0E2:1;
		unsigned char FPWM0E3:1;
		unsigned char FPWM0E4:1;
		unsigned char FPWM0E5:1;
		unsigned char :1;
		unsigned char :1;
	};
} __PWM0CR1bits_t;
extern volatile __PWM0CR1bits_t __at(PWM0CR1_ADDR) PWM0CR1bits;

#define FPWM0E0   	PWM0CR1bits.FPWM0E0 	/* bit 0 */
#define FPWM0E1   	PWM0CR1bits.FPWM0E1 	/* bit 1 */
#define FPWM0E2   	PWM0CR1bits.FPWM0E2 	/* bit 2 */
#define FPWM0E3   	PWM0CR1bits.FPWM0E3 	/* bit 3 */
#define FPWM0E4   	PWM0CR1bits.FPWM0E4 	/* bit 4 */
#define FPWM0E5   	PWM0CR1bits.FPWM0E5 	/* bit 5 */

// ----- PWM0CR2 Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char PWM0D0:1;
		unsigned char PWM0D1:1;
		unsigned char PWM0D2:1;
		unsigned char PWM0DB:1;
		unsigned char :1;
		unsigned char :1;
		unsigned char :1;
		unsigned char :1;
	};
} __PWM0CR2bits_t;
extern volatile __PWM0CR2bits_t __at(PWM0CR2_ADDR) PWM0CR2bits;

#define PWM0D0    	PWM0CR2bits.PWM0D0  	/* bit 0 */
#define PWM0D1    	PWM0CR2bits.PWM0D1  	/* bit 1 */
#define PWM0D2    	PWM0CR2bits.PWM0D2  	/* bit 2 */
#define PWM0DB    	PWM0CR2bits.PWM0DB  	/* bit 3 */

// ----- 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 FPWM0EN:1;
		unsigned char PWM0EN: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 FPWM0EN   	T0CRbits.FPWM0EN    	/* bit 5 */
#define PWM0EN    	T0CRbits.PWM0EN     	/* bit 6 */
#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 */

// ----- T0DATA Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char T0DATA0:1;
		unsigned char T0DATA1:1;
		unsigned char T0DATA2:1;
		unsigned char T0DATA3:1;
		unsigned char T0DATA4:1;
		unsigned char T0DATA5:1;
		unsigned char T0DATA6:1;
		unsigned char T0DATA7:1;
	};
} __T0DATAbits_t;
extern volatile __T0DATAbits_t __at(T0DATA_ADDR) T0DATAbits;

#define T0DATA0   	T0DATAbits.T0DATA0  	/* bit 0 */
#define T0DATA1   	T0DATAbits.T0DATA1  	/* bit 1 */
#define T0DATA2   	T0DATAbits.T0DATA2  	/* bit 2 */
#define T0DATA3   	T0DATAbits.T0DATA3  	/* bit 3 */
#define T0DATA4   	T0DATAbits.T0DATA4  	/* bit 4 */
#define T0DATA5   	T0DATAbits.T0DATA5  	/* bit 5 */
#define T0DATA6   	T0DATAbits.T0DATA6  	/* bit 6 */
#define T0DATA7   	T0DATAbits.T0DATA7  	/* bit 7 */

// ----- T1CR 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 :1;
		unsigned char T1EN:1;
	};
} __T1CRbits_t;
extern volatile __T1CRbits_t __at(T1CR_ADDR) T1CRbits;

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

// ----- T1CNT 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;
	};
} __T1CNTbits_t;
extern volatile __T1CNTbits_t __at(T1CNT_ADDR) T1CNTbits;

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

// ----- T1LOAD 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;
	};
} __T1LOADbits_t;
extern volatile __T1LOADbits_t __at(T1LOAD_ADDR) T1LOADbits;

#define T1LOAD0   	T1LOADbits.T1LOAD0  	/* bit 0 */
#define T1LOAD1   	T1LOADbits.T1LOAD1  	/* bit 1 */
#define T1LOAD2   	T1LOADbits.T1LOAD2  	/* bit 2 */
#define T1LOAD3   	T1LOADbits.T1LOAD3  	/* bit 3 */
#define T1LOAD4   	T1LOADbits.T1LOAD4  	/* bit 4 */
#define T1LOAD5   	T1LOADbits.T1LOAD5  	/* bit 5 */
#define T1LOAD6   	T1LOADbits.T1LOAD6  	/* bit 6 */
#define T1LOAD7   	T1LOADbits.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 :1;
		unsigned char T2MOD: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 T2MOD     	T2CRbits.T2MOD      	/* 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 */

// ----- T2EFR Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char T2PLS:1;
		unsigned char T2PIS:1;
		unsigned char T2ISS:1;
		unsigned char T2PCT0:1;
		unsigned char T2PCT1:1;
		unsigned char T2PMOD:1;
		unsigned char T2PINT:1;
		unsigned char :1;
	};
} __T2EFRbits_t;
extern volatile __T2EFRbits_t __at(T2EFR_ADDR) T2EFRbits;

#define T2PLS     	T2EFRbits.T2PLS     	/* bit 0 */
#define T2PIS     	T2EFRbits.T2PIS     	/* bit 1 */
#define T2ISS     	T2EFRbits.T2ISS     	/* bit 2 */
#define T2PCT0    	T2EFRbits.T2PCT0    	/* bit 3 */
#define T2PCT1    	T2EFRbits.T2PCT1    	/* bit 4 */
#define T2PMOD    	T2EFRbits.T2PMOD    	/* bit 5 */
#define T2PINT    	T2EFRbits.T2PINT    	/* bit 6 */

// ----- T3CR Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char T3PRS0:1;
		unsigned char T3PRS1:1;
		unsigned char T3PRS2:1;
		unsigned char T3CKS0:1;
		unsigned char T3CKS1:1;
		unsigned char :1;
		unsigned char T3MOD:1;
		unsigned char T3EN:1;
	};
} __T3CRbits_t;
extern volatile __T3CRbits_t __at(T3CR_ADDR) T3CRbits;

#define T3PRS0    	T3CRbits.T3PRS0     	/* bit 0 */
#define T3PRS1    	T3CRbits.T3PRS1     	/* bit 1 */
#define T3PRS2    	T3CRbits.T3PRS2     	/* bit 2 */
#define T3CKS0    	T3CRbits.T3CKS0     	/* bit 3 */
#define T3CKS1    	T3CRbits.T3CKS1     	/* bit 4 */
#define T3MOD     	T3CRbits.T3MOD      	/* bit 6 */
#define T3EN      	T3CRbits.T3EN       	/* bit 7 */

// ----- T3CNT Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char T3CNT0:1;
		unsigned char T3CNT1:1;
		unsigned char T3CNT2:1;
		unsigned char T3CNT3:1;
		unsigned char T3CNT4:1;
		unsigned char T3CNT5:1;
		unsigned char T3CNT6:1;
		unsigned char T3CNT7:1;
	};
} __T3CNTbits_t;
extern volatile __T3CNTbits_t __at(T3CNT_ADDR) T3CNTbits;

#define T3CNT0    	T3CNTbits.T3CNT0    	/* bit 0 */
#define T3CNT1    	T3CNTbits.T3CNT1    	/* bit 1 */
#define T3CNT2    	T3CNTbits.T3CNT2    	/* bit 2 */
#define T3CNT3    	T3CNTbits.T3CNT3    	/* bit 3 */
#define T3CNT4    	T3CNTbits.T3CNT4    	/* bit 4 */
#define T3CNT5    	T3CNTbits.T3CNT5    	/* bit 5 */
#define T3CNT6    	T3CNTbits.T3CNT6    	/* bit 6 */
#define T3CNT7    	T3CNTbits.T3CNT7    	/* bit 7 */

// ----- T3LOAD Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char T3LOAD0:1;
		unsigned char T3LOAD1:1;
		unsigned char T3LOAD2:1;
		unsigned char T3LOAD3:1;
		unsigned char T3LOAD4:1;
		unsigned char T3LOAD5:1;
		unsigned char T3LOAD6:1;
		unsigned char T3LOAD7:1;
	};
} __T3LOADbits_t;
extern volatile __T3LOADbits_t __at(T3LOAD_ADDR) T3LOADbits;

#define T3LOAD0   	T3LOADbits.T3LOAD0  	/* bit 0 */
#define T3LOAD1   	T3LOADbits.T3LOAD1  	/* bit 1 */
#define T3LOAD2   	T3LOADbits.T3LOAD2  	/* bit 2 */
#define T3LOAD3   	T3LOADbits.T3LOAD3  	/* bit 3 */
#define T3LOAD4   	T3LOADbits.T3LOAD4  	/* bit 4 */
#define T3LOAD5   	T3LOADbits.T3LOAD5  	/* bit 5 */
#define T3LOAD6   	T3LOADbits.T3LOAD6  	/* bit 6 */
#define T3LOAD7   	T3LOADbits.T3LOAD7  	/* bit 7 */

// ----- IICCR Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char RACK:1;
		unsigned char IICEN:1;
		unsigned char MSTCMD:1;
		unsigned char SACK:1;
		unsigned char IICMOD:1;
		unsigned char IICBUSY:1;
		unsigned char IICAAS:1;
		unsigned char IICEOF:1;
	};
} __IICCRbits_t;
extern volatile __IICCRbits_t __at(IICCR_ADDR) IICCRbits;

#define RACK      	IICCRbits.RACK      	/* bit 0 */
#define IICEN     	IICCRbits.IICEN     	/* bit 1 */
#define MSTCMD    	IICCRbits.MSTCMD    	/* bit 2 */
#define SACK      	IICCRbits.SACK      	/* bit 3 */
#define IICMOD    	IICCRbits.IICMOD    	/* bit 4 */
#define IICBUSY   	IICCRbits.IICBUSY   	/* bit 5 */
#define IICAAS    	IICCRbits.IICAAS    	/* bit 6 */
#define IICEOF    	IICCRbits.IICEOF    	/* bit 7 */

// ----- IICAR Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char :1;
		unsigned char IICA0:1;
		unsigned char IICA1:1;
		unsigned char IICA2:1;
		unsigned char IICA3:1;
		unsigned char IICA4:1;
		unsigned char IICA5:1;
		unsigned char IICA6:1;
	};
} __IICARbits_t;
extern volatile __IICARbits_t __at(IICAR_ADDR) IICARbits;

#define IICA0     	IICARbits.IICA0     	/* bit 1 */
#define IICA1     	IICARbits.IICA1     	/* bit 2 */
#define IICA2     	IICARbits.IICA2     	/* bit 3 */
#define IICA3     	IICARbits.IICA3     	/* bit 4 */
#define IICA4     	IICARbits.IICA4     	/* bit 5 */
#define IICA5     	IICARbits.IICA5     	/* bit 6 */
#define IICA6     	IICARbits.IICA6     	/* bit 7 */

// ----- IICDR Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char IICD0:1;
		unsigned char IICD1:1;
		unsigned char IICD2:1;
		unsigned char IICD3:1;
		unsigned char IICD4:1;
		unsigned char IICD5:1;
		unsigned char IICD6:1;
		unsigned char IICD7:1;
	};
} __IICDRbits_t;
extern volatile __IICDRbits_t __at(IICDR_ADDR) IICDRbits;

#define IICD0     	IICDRbits.IICD0     	/* bit 0 */
#define IICD1     	IICDRbits.IICD1     	/* bit 1 */
#define IICD2     	IICDRbits.IICD2     	/* bit 2 */
#define IICD3     	IICDRbits.IICD3     	/* bit 3 */
#define IICD4     	IICDRbits.IICD4     	/* bit 4 */
#define IICD5     	IICDRbits.IICD5     	/* bit 5 */
#define IICD6     	IICDRbits.IICD6     	/* bit 6 */
#define IICD7     	IICDRbits.IICD7     	/* bit 7 */

// ----- 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 */

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

#define EERW      	EECRbits.EERW       	/* bit 6 */
#define EETRIG    	EECRbits.EETRIG     	/* bit 7 */

// ----- EEMASK Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char EEMASK0:1;
		unsigned char EEMASK1:1;
		unsigned char EEMASK2:1;
		unsigned char EEMASK3:1;
		unsigned char EEMASK4:1;
		unsigned char EEMASK5:1;
		unsigned char EEMASK6:1;
		unsigned char EEMASK7:1;
	};
} __EEMASKbits_t;
extern volatile __EEMASKbits_t __at(EEMASK_ADDR) EEMASKbits;

#define EEMASK0   	EEMASKbits.EEMASK0  	/* bit 0 */
#define EEMASK1   	EEMASKbits.EEMASK1  	/* bit 1 */
#define EEMASK2   	EEMASKbits.EEMASK2  	/* bit 2 */
#define EEMASK3   	EEMASKbits.EEMASK3  	/* bit 3 */
#define EEMASK4   	EEMASKbits.EEMASK4  	/* bit 4 */
#define EEMASK5   	EEMASKbits.EEMASK5  	/* bit 5 */
#define EEMASK6   	EEMASKbits.EEMASK6  	/* bit 6 */
#define EEMASK7   	EEMASKbits.EEMASK7  	/* 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 */

// ----- 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 ADEN:1;
		unsigned char ADEOC:1;
		unsigned char ADVRS3:1;
		unsigned char CPVIREN:1;
		unsigned char ADCHS0:1;
		unsigned char ADCHS1:1;
		unsigned char ADCHS2:1;
		unsigned char ADCHS3:1;
	};
} __ADCR0bits_t;
extern volatile __ADCR0bits_t __at(ADCR0_ADDR) ADCR0bits;

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

// ----- ADCR1 Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char ADSPS0:1;
		unsigned char ADSPS1:1;
		unsigned char :1;
		unsigned char :1;
		unsigned char ADCKS0:1;
		unsigned char ADCKS1:1;
		unsigned char ADCKS2: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 ADCKS0    	ADCR1bits.ADCKS0    	/* bit 4 */
#define ADCKS1    	ADCR1bits.ADCKS1    	/* bit 5 */
#define ADCKS2    	ADCR1bits.ADCKS2    	/* 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 */

// ----- P0ADCR Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char P00DC:1;
		unsigned char P01DC:1;
		unsigned char P02DC:1;
		unsigned char P03DC:1;
		unsigned char P04DC:1;
		unsigned char P05DC:1;
		unsigned char P06DC:1;
		unsigned char P07DC: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 */
#define P03DC     	P0ADCRbits.P03DC    	/* bit 3 */
#define P04DC     	P0ADCRbits.P04DC    	/* bit 4 */
#define P05DC     	P0ADCRbits.P05DC    	/* bit 5 */
#define P06DC     	P0ADCRbits.P06DC    	/* bit 6 */
#define P07DC     	P0ADCRbits.P07DC    	/* bit 7 */

// ----- 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 P16DC:1;
		unsigned char P17DC: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 */
#define P16DC     	P1ADCRbits.P16DC    	/* bit 6 */
#define P17DC     	P1ADCRbits.P17DC    	/* bit 7 */

// ----- 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 OSADJTD:1;
		unsigned char :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 OSADJTD   	OSADJCRbits.OSADJTD 	/* bit 5 */
#define OSADJEN   	OSADJCRbits.OSADJEN 	/* bit 7 */

// ----- MEFCR Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char ADVRS0:1;
		unsigned char ADVRS1:1;
		unsigned char ADVRS2:1;
		unsigned char PPGOP:1;
		unsigned char POFFS:1;
		unsigned char :1;
		unsigned char :1;
		unsigned char :1;
	};
} __MEFCRbits_t;
extern volatile __MEFCRbits_t __at(MEFCR_ADDR) MEFCRbits;

#define ADVRS0    	MEFCRbits.ADVRS0    	/* bit 0 */
#define ADVRS1    	MEFCRbits.ADVRS1    	/* bit 1 */
#define ADVRS2    	MEFCRbits.ADVRS2    	/* bit 2 */
#define PPGOP     	MEFCRbits.PPGOP     	/* bit 3 */
#define POFFS     	MEFCRbits.POFFS     	/* bit 4 */

// ----- PPGCR Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char PPGPRS0:1;
		unsigned char PPGPRS1:1;
		unsigned char PPGSTR:1;
		unsigned char PSTPC3EN:1;
		unsigned char PSTPC2EN:1;
		unsigned char PSTREN:1;
		unsigned char POLEV:1;
		unsigned char PPGEN:1;
	};
} __PPGCRbits_t;
extern volatile __PPGCRbits_t __at(PPGCR_ADDR) PPGCRbits;

#define PPGPRS0   	PPGCRbits.PPGPRS0   	/* bit 0 */
#define PPGPRS1   	PPGCRbits.PPGPRS1   	/* bit 1 */
#define PPGSTR    	PPGCRbits.PPGSTR    	/* bit 2 */
#define PSTPC3EN  	PPGCRbits.PSTPC3EN  	/* bit 3 */
#define PSTPC2EN  	PPGCRbits.PSTPC2EN  	/* bit 4 */
#define PSTREN    	PPGCRbits.PSTREN    	/* bit 5 */
#define POLEV     	PPGCRbits.POLEV     	/* bit 6 */
#define PPGEN     	PPGCRbits.PPGEN     	/* bit 7 */

// ----- PPGLDH Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char PGLOAD8:1;
		unsigned char PGLOAD9:1;
		unsigned char PGLOAD10:1;
		unsigned char :1;
		unsigned char :1;
		unsigned char :1;
		unsigned char :1;
		unsigned char :1;
	};
} __PPGLDHbits_t;
extern volatile __PPGLDHbits_t __at(PPGLDH_ADDR) PPGLDHbits;

#define PGLOAD8   	PPGLDHbits.PGLOAD8  	/* bit 0 */
#define PGLOAD9   	PPGLDHbits.PGLOAD9  	/* bit 1 */
#define PGLOAD10  	PPGLDHbits.PGLOAD10 	/* bit 2 */

// ----- PPGLDL Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char PGLOAD0:1;
		unsigned char PGLOAD1:1;
		unsigned char PGLOAD2:1;
		unsigned char PGLOAD3:1;
		unsigned char PGLOAD4:1;
		unsigned char PGLOAD5:1;
		unsigned char PGLOAD6:1;
		unsigned char PGLOAD7:1;
	};
} __PPGLDLbits_t;
extern volatile __PPGLDLbits_t __at(PPGLDL_ADDR) PPGLDLbits;

#define PGLOAD0   	PPGLDLbits.PGLOAD0  	/* bit 0 */
#define PGLOAD1   	PPGLDLbits.PGLOAD1  	/* bit 1 */
#define PGLOAD2   	PPGLDLbits.PGLOAD2  	/* bit 2 */
#define PGLOAD3   	PPGLDLbits.PGLOAD3  	/* bit 3 */
#define PGLOAD4   	PPGLDLbits.PGLOAD4  	/* bit 4 */
#define PGLOAD5   	PPGLDLbits.PGLOAD5  	/* bit 5 */
#define PGLOAD6   	PPGLDLbits.PGLOAD6  	/* bit 6 */
#define PGLOAD7   	PPGLDLbits.PGLOAD7  	/* bit 7 */

// ----- PPGTDL Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char PPGTDL0:1;
		unsigned char PPGTDL1:1;
		unsigned char PPGTDL2:1;
		unsigned char PPGTDL3:1;
		unsigned char PPGTDL4:1;
		unsigned char PPGTDL5:1;
		unsigned char PPGTDL6:1;
		unsigned char PPGTDLM:1;
	};
} __PPGTDLbits_t;
extern volatile __PPGTDLbits_t __at(PPGTDL_ADDR) PPGTDLbits;

#define PPGTDL0   	PPGTDLbits.PPGTDL0  	/* bit 0 */
#define PPGTDL1   	PPGTDLbits.PPGTDL1  	/* bit 1 */
#define PPGTDL2   	PPGTDLbits.PPGTDL2  	/* bit 2 */
#define PPGTDL3   	PPGTDLbits.PPGTDL3  	/* bit 3 */
#define PPGTDL4   	PPGTDLbits.PPGTDL4  	/* bit 4 */
#define PPGTDL5   	PPGTDLbits.PPGTDL5  	/* bit 5 */
#define PPGTDL6   	PPGTDLbits.PPGTDL6  	/* bit 6 */
#define PPGTDLM   	PPGTDLbits.PPGTDLM  	/* bit 7 */

// ----- PPGTDB Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char PPGTDB0:1;
		unsigned char PPGTDB1:1;
		unsigned char PPGTDB2:1;
		unsigned char PPGTDB3:1;
		unsigned char PPGTDB4:1;
		unsigned char PPGTDB5:1;
		unsigned char PPGTDB6:1;
		unsigned char PPGTIS:1;
	};
} __PPGTDBbits_t;
extern volatile __PPGTDBbits_t __at(PPGTDB_ADDR) PPGTDBbits;

#define PPGTDB0   	PPGTDBbits.PPGTDB0  	/* bit 0 */
#define PPGTDB1   	PPGTDBbits.PPGTDB1  	/* bit 1 */
#define PPGTDB2   	PPGTDBbits.PPGTDB2  	/* bit 2 */
#define PPGTDB3   	PPGTDBbits.PPGTDB3  	/* bit 3 */
#define PPGTDB4   	PPGTDBbits.PPGTDB4  	/* bit 4 */
#define PPGTDB5   	PPGTDBbits.PPGTDB5  	/* bit 5 */
#define PPGTDB6   	PPGTDBbits.PPGTDB6  	/* bit 6 */
#define PPGTIS    	PPGTDBbits.PPGTIS   	/* bit 7 */

// ----- OPACR Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char OPAPS0:1;
		unsigned char OPAPS1:1;
		unsigned char OPAOS0:1;
		unsigned char OPAOS1:1;
		unsigned char OPAOS2:1;
		unsigned char :1;
		unsigned char OPAOF:1;
		unsigned char OPAEN:1;
	};
} __OPACRbits_t;
extern volatile __OPACRbits_t __at(OPACR_ADDR) OPACRbits;

#define OPAPS0    	OPACRbits.OPAPS0    	/* bit 0 */
#define OPAPS1    	OPACRbits.OPAPS1    	/* bit 1 */
#define OPAOS0    	OPACRbits.OPAOS0    	/* bit 2 */
#define OPAOS1    	OPACRbits.OPAOS1    	/* bit 3 */
#define OPAOS2    	OPACRbits.OPAOS2    	/* bit 4 */
#define OPAOF     	OPACRbits.OPAOF     	/* bit 6 */
#define OPAEN     	OPACRbits.OPAEN     	/* bit 7 */

// ----- OPACLR Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char OPACLR0:1;
		unsigned char OPACLR1:1;
		unsigned char OPACLR2:1;
		unsigned char OPACLR3:1;
		unsigned char OPACLR4:1;
		unsigned char OPACLR5:1;
		unsigned char OPACLRS:1;
		unsigned char OPACLRE:1;
	};
} __OPACLRbits_t;
extern volatile __OPACLRbits_t __at(OPACLR_ADDR) OPACLRbits;

#define OPACLR0   	OPACLRbits.OPACLR0  	/* bit 0 */
#define OPACLR1   	OPACLRbits.OPACLR1  	/* bit 1 */
#define OPACLR2   	OPACLRbits.OPACLR2  	/* bit 2 */
#define OPACLR3   	OPACLRbits.OPACLR3  	/* bit 3 */
#define OPACLR4   	OPACLRbits.OPACLR4  	/* bit 4 */
#define OPACLR5   	OPACLRbits.OPACLR5  	/* bit 5 */
#define OPACLRS   	OPACLRbits.OPACLRS  	/* bit 6 */
#define OPACLRE   	OPACLRbits.OPACLRE  	/* bit 7 */

// ----- CPCR0 Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char CP0EN:1;
		unsigned char CP1EN:1;
		unsigned char CP2EN:1;
		unsigned char CP3EN:1;
		unsigned char CP1NS:1;
		unsigned char CP3NS0:1;
		unsigned char CP3NS1:1;
		unsigned char :1;
	};
} __CPCR0bits_t;
extern volatile __CPCR0bits_t __at(CPCR0_ADDR) CPCR0bits;

#define CP0EN     	CPCR0bits.CP0EN     	/* bit 0 */
#define CP1EN     	CPCR0bits.CP1EN     	/* bit 1 */
#define CP2EN     	CPCR0bits.CP2EN     	/* bit 2 */
#define CP3EN     	CPCR0bits.CP3EN     	/* bit 3 */
#define CP1NS     	CPCR0bits.CP1NS     	/* bit 4 */
#define CP3NS0    	CPCR0bits.CP3NS0    	/* bit 5 */
#define CP3NS1    	CPCR0bits.CP3NS1    	/* bit 6 */

// ----- CPSR Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char CP0OF:1;
		unsigned char CP1OF:1;
		unsigned char CP2OF:1;
		unsigned char CP3OF:1;
		unsigned char :1;
		unsigned char :1;
		unsigned char :1;
		unsigned char :1;
	};
} __CPSRbits_t;
extern volatile __CPSRbits_t __at(CPSR_ADDR) CPSRbits;

#define CP0OF     	CPSRbits.CP0OF      	/* bit 0 */
#define CP1OF     	CPSRbits.CP1OF      	/* bit 1 */
#define CP2OF     	CPSRbits.CP2OF      	/* bit 2 */
#define CP3OF     	CPSRbits.CP3OF      	/* bit 3 */

// ----- CPVR0 Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char CP1VS0:1;
		unsigned char CP1VS1:1;
		unsigned char CP1VS2:1;
		unsigned char CP1VS3:1;
		unsigned char CP2VS0:1;
		unsigned char CP2VS1:1;
		unsigned char CP2VS2:1;
		unsigned char CPVRS:1;
	};
} __CPVR0bits_t;
extern volatile __CPVR0bits_t __at(CPVR0_ADDR) CPVR0bits;

#define CP1VS0    	CPVR0bits.CP1VS0    	/* bit 0 */
#define CP1VS1    	CPVR0bits.CP1VS1    	/* bit 1 */
#define CP1VS2    	CPVR0bits.CP1VS2    	/* bit 2 */
#define CP1VS3    	CPVR0bits.CP1VS3    	/* bit 3 */
#define CP2VS0    	CPVR0bits.CP2VS0    	/* bit 4 */
#define CP2VS1    	CPVR0bits.CP2VS1    	/* bit 5 */
#define CP2VS2    	CPVR0bits.CP2VS2    	/* bit 6 */
#define CPVRS     	CPVR0bits.CPVRS     	/* bit 7 */

// ----- CPVR1 Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char CP3VS0:1;
		unsigned char CP3VS1:1;
		unsigned char CP3VS2:1;
		unsigned char CP3VS3:1;
		unsigned char CP3VS4:1;
		unsigned char :1;
		unsigned char :1;
		unsigned char :1;
	};
} __CPVR1bits_t;
extern volatile __CPVR1bits_t __at(CPVR1_ADDR) CPVR1bits;

#define CP3VS0    	CPVR1bits.CP3VS0    	/* bit 0 */
#define CP3VS1    	CPVR1bits.CP3VS1    	/* bit 1 */
#define CP3VS2    	CPVR1bits.CP3VS2    	/* bit 2 */
#define CP3VS3    	CPVR1bits.CP3VS3    	/* bit 3 */
#define CP3VS4    	CPVR1bits.CP3VS4    	/* bit 4 */

// ----- CP0CLR Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char CP0CLR0:1;
		unsigned char CP0CLR1:1;
		unsigned char CP0CLR2:1;
		unsigned char CP0CLR3:1;
		unsigned char CP0CLR4:1;
		unsigned char CP0CLR5:1;
		unsigned char CP0CLRS:1;
		unsigned char CP0CLRE:1;
	};
} __CP0CLRbits_t;
extern volatile __CP0CLRbits_t __at(CP0CLR_ADDR) CP0CLRbits;

#define CP0CLR0   	CP0CLRbits.CP0CLR0  	/* bit 0 */
#define CP0CLR1   	CP0CLRbits.CP0CLR1  	/* bit 1 */
#define CP0CLR2   	CP0CLRbits.CP0CLR2  	/* bit 2 */
#define CP0CLR3   	CP0CLRbits.CP0CLR3  	/* bit 3 */
#define CP0CLR4   	CP0CLRbits.CP0CLR4  	/* bit 4 */
#define CP0CLR5   	CP0CLRbits.CP0CLR5  	/* bit 5 */
#define CP0CLRS   	CP0CLRbits.CP0CLRS  	/* bit 6 */
#define CP0CLRE   	CP0CLRbits.CP0CLRE  	/* bit 7 */

// ----- CP1CLR Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char CP1CLR0:1;
		unsigned char CP1CLR1:1;
		unsigned char CP1CLR2:1;
		unsigned char CP1CLR3:1;
		unsigned char CP1CLR4:1;
		unsigned char CP1CLR5:1;
		unsigned char CP1CLRS:1;
		unsigned char CP1CLRE:1;
	};
} __CP1CLRbits_t;
extern volatile __CP1CLRbits_t __at(CP1CLR_ADDR) CP1CLRbits;

#define CP1CLR0   	CP1CLRbits.CP1CLR0  	/* bit 0 */
#define CP1CLR1   	CP1CLRbits.CP1CLR1  	/* bit 1 */
#define CP1CLR2   	CP1CLRbits.CP1CLR2  	/* bit 2 */
#define CP1CLR3   	CP1CLRbits.CP1CLR3  	/* bit 3 */
#define CP1CLR4   	CP1CLRbits.CP1CLR4  	/* bit 4 */
#define CP1CLR5   	CP1CLRbits.CP1CLR5  	/* bit 5 */
#define CP1CLRS   	CP1CLRbits.CP1CLRS  	/* bit 6 */
#define CP1CLRE   	CP1CLRbits.CP1CLRE  	/* bit 7 */

// ----- CP2CLR Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char CP2CLR0:1;
		unsigned char CP2CLR1:1;
		unsigned char CP2CLR2:1;
		unsigned char CP2CLR3:1;
		unsigned char CP2CLR4:1;
		unsigned char CP2CLR5:1;
		unsigned char CP2CLRS:1;
		unsigned char CP2CLRE:1;
	};
} __CP2CLRbits_t;
extern volatile __CP2CLRbits_t __at(CP2CLR_ADDR) CP2CLRbits;

#define CP2CLR0   	CP2CLRbits.CP2CLR0  	/* bit 0 */
#define CP2CLR1   	CP2CLRbits.CP2CLR1  	/* bit 1 */
#define CP2CLR2   	CP2CLRbits.CP2CLR2  	/* bit 2 */
#define CP2CLR3   	CP2CLRbits.CP2CLR3  	/* bit 3 */
#define CP2CLR4   	CP2CLRbits.CP2CLR4  	/* bit 4 */
#define CP2CLR5   	CP2CLRbits.CP2CLR5  	/* bit 5 */
#define CP2CLRS   	CP2CLRbits.CP2CLRS  	/* bit 6 */
#define CP2CLRE   	CP2CLRbits.CP2CLRE  	/* bit 7 */

// ----- CP3CLR Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char CP3CLR0:1;
		unsigned char CP3CLR1:1;
		unsigned char CP3CLR2:1;
		unsigned char CP3CLR3:1;
		unsigned char CP3CLR4:1;
		unsigned char CP3CLR5:1;
		unsigned char CP3CLRS:1;
		unsigned char CP3CLRE:1;
	};
} __CP3CLRbits_t;
extern volatile __CP3CLRbits_t __at(CP3CLR_ADDR) CP3CLRbits;

#define CP3CLR0   	CP3CLRbits.CP3CLR0  	/* bit 0 */
#define CP3CLR1   	CP3CLRbits.CP3CLR1  	/* bit 1 */
#define CP3CLR2   	CP3CLRbits.CP3CLR2  	/* bit 2 */
#define CP3CLR3   	CP3CLRbits.CP3CLR3  	/* bit 3 */
#define CP3CLR4   	CP3CLRbits.CP3CLR4  	/* bit 4 */
#define CP3CLR5   	CP3CLRbits.CP3CLR5  	/* bit 5 */
#define CP3CLRS   	CP3CLRbits.CP3CLRS  	/* bit 6 */
#define CP3CLRE   	CP3CLRbits.CP3CLRE  	/* bit 7 */

// ----- CPCR1 Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char CP2NS0:1;
		unsigned char CP2NS1:1;
		unsigned char :1;
		unsigned char :1;
		unsigned char :1;
		unsigned char :1;
		unsigned char :1;
		unsigned char :1;
	};
} __CPCR1bits_t;
extern volatile __CPCR1bits_t __at(CPCR1_ADDR) CPCR1bits;

#define CP2NS0    	CPCR1bits.CP2NS0    	/* bit 0 */
#define CP2NS1    	CPCR1bits.CP2NS1    	/* bit 1 */

// ----- CPCR2 Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char CP0NV:1;
		unsigned char CP1NV:1;
		unsigned char CP2NV:1;
		unsigned char CP3NV:1;
		unsigned char :1;
		unsigned char :1;
		unsigned char :1;
		unsigned char :1;
	};
} __CPCR2bits_t;
extern volatile __CPCR2bits_t __at(CPCR2_ADDR) CPCR2bits;

#define CP0NV     	CPCR2bits.CP0NV     	/* bit 0 */
#define CP1NV     	CPCR2bits.CP1NV     	/* bit 1 */
#define CP2NV     	CPCR2bits.CP2NV     	/* bit 2 */
#define CP3NV     	CPCR2bits.CP3NV     	/* bit 3 */

// ----- CPDB0 Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char CP1DB0:1;
		unsigned char CP1DB1:1;
		unsigned char CP1DB2:1;
		unsigned char CP1DB3:1;
		unsigned char CP2DB0:1;
		unsigned char CP2DB1:1;
		unsigned char CP2DB2:1;
		unsigned char CP2DB3:1;
	};
} __CPDB0bits_t;
extern volatile __CPDB0bits_t __at(CPDB0_ADDR) CPDB0bits;

#define CP1DB0    	CPDB0bits.CP1DB0    	/* bit 0 */
#define CP1DB1    	CPDB0bits.CP1DB1    	/* bit 1 */
#define CP1DB2    	CPDB0bits.CP1DB2    	/* bit 2 */
#define CP1DB3    	CPDB0bits.CP1DB3    	/* bit 3 */
#define CP2DB0    	CPDB0bits.CP2DB0    	/* bit 4 */
#define CP2DB1    	CPDB0bits.CP2DB1    	/* bit 5 */
#define CP2DB2    	CPDB0bits.CP2DB2    	/* bit 6 */
#define CP2DB3    	CPDB0bits.CP2DB3    	/* bit 7 */

// ----- CPDB1 Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char CP3DB0:1;
		unsigned char CP3DB1:1;
		unsigned char CP3DB2:1;
		unsigned char CP3DB3:1;
		unsigned char :1;
		unsigned char :1;
		unsigned char :1;
		unsigned char :1;
	};
} __CPDB1bits_t;
extern volatile __CPDB1bits_t __at(CPDB1_ADDR) CPDB1bits;

#define CP3DB0    	CPDB1bits.CP3DB0    	/* bit 0 */
#define CP3DB1    	CPDB1bits.CP3DB1    	/* bit 1 */
#define CP3DB2    	CPDB1bits.CP3DB2    	/* bit 2 */
#define CP3DB3    	CPDB1bits.CP3DB3    	/* bit 3 */

// ----- DBGCR Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char DBGEN:1;
		unsigned char :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 DBGEN     	DBGCRbits.DBGEN     	/* bit 0 */

// ----- 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 */

#endif
