#pragma once
#include <Register/Utility.hpp>
namespace Kvasir {
//Serial Communication Interface
    namespace Uart3Bdh{    ///<UART Baud Rate Registers:High
        using Addr = Register::Address<0x4006d000,0xffffff20,0x00000000,unsigned char>;
        ///UART Baud Rate Bits
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(4,0),Register::ReadWriteAccess,unsigned> sbr{};
        ///RxD Input Active Edge Interrupt Enable
        enum class RxedgieVal {
            v0=0x00000000,     ///<Hardware interrupts from RXEDGIF disabled (use polling).
            v1=0x00000001,     ///<RXEDGIF interrupt request enabled.
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(6,6),Register::ReadWriteAccess,RxedgieVal> rxedgie{};
        namespace RxedgieValC{
            constexpr Register::FieldValue<decltype(rxedgie)::Type,RxedgieVal::v0> v0{};
            constexpr Register::FieldValue<decltype(rxedgie)::Type,RxedgieVal::v1> v1{};
        }
        ///LIN Break Detect Interrupt Enable
        enum class LbkdieVal {
            v0=0x00000000,     ///<LBKDIF interrupt requests disabled.
            v1=0x00000001,     ///<LBKDIF interrupt requests enabled.
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(7,7),Register::ReadWriteAccess,LbkdieVal> lbkdie{};
        namespace LbkdieValC{
            constexpr Register::FieldValue<decltype(lbkdie)::Type,LbkdieVal::v0> v0{};
            constexpr Register::FieldValue<decltype(lbkdie)::Type,LbkdieVal::v1> v1{};
        }
    }
    namespace Uart3Bdl{    ///<UART Baud Rate Registers: Low
        using Addr = Register::Address<0x4006d001,0xffffff00,0x00000000,unsigned char>;
        ///UART Baud Rate Bits
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(7,0),Register::ReadWriteAccess,unsigned> sbr{};
    }
    namespace Uart3C1{    ///<UART Control Register 1
        using Addr = Register::Address<0x4006d002,0xffffff00,0x00000000,unsigned char>;
        ///Parity Type
        enum class PtVal {
            v0=0x00000000,     ///<Even parity.
            v1=0x00000001,     ///<Odd parity.
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(0,0),Register::ReadWriteAccess,PtVal> pt{};
        namespace PtValC{
            constexpr Register::FieldValue<decltype(pt)::Type,PtVal::v0> v0{};
            constexpr Register::FieldValue<decltype(pt)::Type,PtVal::v1> v1{};
        }
        ///Parity Enable
        enum class PeVal {
            v0=0x00000000,     ///<Parity function disabled.
            v1=0x00000001,     ///<Parity function enabled.
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(1,1),Register::ReadWriteAccess,PeVal> pe{};
        namespace PeValC{
            constexpr Register::FieldValue<decltype(pe)::Type,PeVal::v0> v0{};
            constexpr Register::FieldValue<decltype(pe)::Type,PeVal::v1> v1{};
        }
        ///Idle Line Type Select
        enum class IltVal {
            v0=0x00000000,     ///<Idle character bit count starts after start bit.
            v1=0x00000001,     ///<Idle character bit count starts after stop bit.
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(2,2),Register::ReadWriteAccess,IltVal> ilt{};
        namespace IltValC{
            constexpr Register::FieldValue<decltype(ilt)::Type,IltVal::v0> v0{};
            constexpr Register::FieldValue<decltype(ilt)::Type,IltVal::v1> v1{};
        }
        ///Receiver Wakeup Method Select
        enum class WakeVal {
            v0=0x00000000,     ///<Idle-line wakeup.
            v1=0x00000001,     ///<Address-mark wakeup.
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(3,3),Register::ReadWriteAccess,WakeVal> wake{};
        namespace WakeValC{
            constexpr Register::FieldValue<decltype(wake)::Type,WakeVal::v0> v0{};
            constexpr Register::FieldValue<decltype(wake)::Type,WakeVal::v1> v1{};
        }
        ///9-bit or 8-bit Mode Select
        enum class MVal {
            v0=0x00000000,     ///<Normal - start + 8 data bits (MSB/LSB first as determined by MSBF) + stop.
            v1=0x00000001,     ///<Use - start + 9 data bits (MSB/LSB first as determined by MSBF) + stop.
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(4,4),Register::ReadWriteAccess,MVal> m{};
        namespace MValC{
            constexpr Register::FieldValue<decltype(m)::Type,MVal::v0> v0{};
            constexpr Register::FieldValue<decltype(m)::Type,MVal::v1> v1{};
        }
        ///Receiver Source Select
        enum class RsrcVal {
            v0=0x00000000,     ///<Selects internal loop back mode and receiver input is internally connected to transmitter output.
            v1=0x00000001,     ///<Single-wire UART mode where the receiver input is connected to the transmit pin input signal.
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(5,5),Register::ReadWriteAccess,RsrcVal> rsrc{};
        namespace RsrcValC{
            constexpr Register::FieldValue<decltype(rsrc)::Type,RsrcVal::v0> v0{};
            constexpr Register::FieldValue<decltype(rsrc)::Type,RsrcVal::v1> v1{};
        }
        ///UART Stops in Wait Mode
        enum class UartswaiVal {
            v0=0x00000000,     ///<UART clock continues to run in wait mode.
            v1=0x00000001,     ///<UART clock freezes while CPU is in wait mode.
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(6,6),Register::ReadWriteAccess,UartswaiVal> uartswai{};
        namespace UartswaiValC{
            constexpr Register::FieldValue<decltype(uartswai)::Type,UartswaiVal::v0> v0{};
            constexpr Register::FieldValue<decltype(uartswai)::Type,UartswaiVal::v1> v1{};
        }
        ///Loop Mode Select
        enum class LoopsVal {
            v0=0x00000000,     ///<Normal operation.
            v1=0x00000001,     ///<Loop mode where transmitter output is internally connected to receiver input. The receiver input is determined by the RSRC bit.
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(7,7),Register::ReadWriteAccess,LoopsVal> loops{};
        namespace LoopsValC{
            constexpr Register::FieldValue<decltype(loops)::Type,LoopsVal::v0> v0{};
            constexpr Register::FieldValue<decltype(loops)::Type,LoopsVal::v1> v1{};
        }
    }
    namespace Uart3C2{    ///<UART Control Register 2
        using Addr = Register::Address<0x4006d003,0xffffff00,0x00000000,unsigned char>;
        ///Send Break
        enum class SbkVal {
            v0=0x00000000,     ///<Normal transmitter operation.
            v1=0x00000001,     ///<Queue break character(s) to be sent.
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(0,0),Register::ReadWriteAccess,SbkVal> sbk{};
        namespace SbkValC{
            constexpr Register::FieldValue<decltype(sbk)::Type,SbkVal::v0> v0{};
            constexpr Register::FieldValue<decltype(sbk)::Type,SbkVal::v1> v1{};
        }
        ///Receiver Wakeup Control
        enum class RwuVal {
            v0=0x00000000,     ///<Normal operation.
            v1=0x00000001,     ///<RWU enables the wakeup function and inhibits further receiver interrupt requests. Normally, hardware wakes the receiver by automatically clearing RWU.
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(1,1),Register::ReadWriteAccess,RwuVal> rwu{};
        namespace RwuValC{
            constexpr Register::FieldValue<decltype(rwu)::Type,RwuVal::v0> v0{};
            constexpr Register::FieldValue<decltype(rwu)::Type,RwuVal::v1> v1{};
        }
        ///Receiver Enable
        enum class ReVal {
            v0=0x00000000,     ///<Receiver off.
            v1=0x00000001,     ///<Receiver on.
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(2,2),Register::ReadWriteAccess,ReVal> re{};
        namespace ReValC{
            constexpr Register::FieldValue<decltype(re)::Type,ReVal::v0> v0{};
            constexpr Register::FieldValue<decltype(re)::Type,ReVal::v1> v1{};
        }
        ///Transmitter Enable
        enum class TeVal {
            v0=0x00000000,     ///<Transmitter off.
            v1=0x00000001,     ///<Transmitter on.
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(3,3),Register::ReadWriteAccess,TeVal> te{};
        namespace TeValC{
            constexpr Register::FieldValue<decltype(te)::Type,TeVal::v0> v0{};
            constexpr Register::FieldValue<decltype(te)::Type,TeVal::v1> v1{};
        }
        ///Idle Line Interrupt Enable
        enum class IlieVal {
            v0=0x00000000,     ///<IDLE interrupt requests disabled.
            v1=0x00000001,     ///<IDLE interrupt requests enabled.
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(4,4),Register::ReadWriteAccess,IlieVal> ilie{};
        namespace IlieValC{
            constexpr Register::FieldValue<decltype(ilie)::Type,IlieVal::v0> v0{};
            constexpr Register::FieldValue<decltype(ilie)::Type,IlieVal::v1> v1{};
        }
        ///Receiver Full Interrupt or DMA Transfer Enable
        enum class RieVal {
            v0=0x00000000,     ///<RDRF interrupt and DMA transfer requests disabled.
            v1=0x00000001,     ///<RDRF interrupt or DMA transfer requests enabled
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(5,5),Register::ReadWriteAccess,RieVal> rie{};
        namespace RieValC{
            constexpr Register::FieldValue<decltype(rie)::Type,RieVal::v0> v0{};
            constexpr Register::FieldValue<decltype(rie)::Type,RieVal::v1> v1{};
        }
        ///Transmission Complete Interrupt Enable
        enum class TcieVal {
            v0=0x00000000,     ///<TC interrupt requests disabled.
            v1=0x00000001,     ///<TC interrupt requests enabled.
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(6,6),Register::ReadWriteAccess,TcieVal> tcie{};
        namespace TcieValC{
            constexpr Register::FieldValue<decltype(tcie)::Type,TcieVal::v0> v0{};
            constexpr Register::FieldValue<decltype(tcie)::Type,TcieVal::v1> v1{};
        }
        ///Transmitter Interrupt or DMA Transfer Enable.
        enum class TieVal {
            v0=0x00000000,     ///<TDRE interrupt and DMA transfer requests disabled.
            v1=0x00000001,     ///<TDRE interrupt or DMA transfer requests enabled.
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(7,7),Register::ReadWriteAccess,TieVal> tie{};
        namespace TieValC{
            constexpr Register::FieldValue<decltype(tie)::Type,TieVal::v0> v0{};
            constexpr Register::FieldValue<decltype(tie)::Type,TieVal::v1> v1{};
        }
    }
    namespace Uart3S1{    ///<UART Status Register 1
        using Addr = Register::Address<0x4006d004,0xffffff00,0x00000000,unsigned char>;
        ///Parity Error Flag
        enum class PfVal {
            v0=0x00000000,     ///<No parity error has been detected since the last time this flag was cleared. If the receive buffer has a depth greater than 1 then there may be data in the receive buffer what was received with a parity error.
            v1=0x00000001,     ///<At least one dataword was received with a parity error since the last time this flag was cleared.
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(0,0),Register::Access<Register::AccessType::readOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,PfVal> pf{};
        namespace PfValC{
            constexpr Register::FieldValue<decltype(pf)::Type,PfVal::v0> v0{};
            constexpr Register::FieldValue<decltype(pf)::Type,PfVal::v1> v1{};
        }
        ///Framing Error Flag
        enum class FeVal {
            v0=0x00000000,     ///<No framing error detected.
            v1=0x00000001,     ///<Framing error.
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(1,1),Register::Access<Register::AccessType::readOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,FeVal> fe{};
        namespace FeValC{
            constexpr Register::FieldValue<decltype(fe)::Type,FeVal::v0> v0{};
            constexpr Register::FieldValue<decltype(fe)::Type,FeVal::v1> v1{};
        }
        ///Noise Flag
        enum class NfVal {
            v0=0x00000000,     ///<No noise detected since the last time this flag was cleared. If the receive buffer has a depth greater than 1 then there may be data in the receiver buffer that was received with noise.
            v1=0x00000001,     ///<At least one dataword was received with noise detected since the last time the flag was cleared.
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(2,2),Register::Access<Register::AccessType::readOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,NfVal> nf{};
        namespace NfValC{
            constexpr Register::FieldValue<decltype(nf)::Type,NfVal::v0> v0{};
            constexpr Register::FieldValue<decltype(nf)::Type,NfVal::v1> v1{};
        }
        ///Receiver Overrun Flag
        enum class Or_Val {
            v0=0x00000000,     ///<No overrun has occurred since the last time the flag was cleared.
            v1=0x00000001,     ///<Overrun has occurred or the overrun flag has not been cleared since the last overrun occured.
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(3,3),Register::Access<Register::AccessType::readOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,Or_Val> or_{};
        namespace Or_ValC{
            constexpr Register::FieldValue<decltype(or_)::Type,Or_Val::v0> v0{};
            constexpr Register::FieldValue<decltype(or_)::Type,Or_Val::v1> v1{};
        }
        ///Idle Line Flag
        enum class IdleVal {
            v0=0x00000000,     ///<Receiver input is either active now or has never become active since the IDLE flag was last cleared.
            v1=0x00000001,     ///<Receiver input has become idle or the flag has not been cleared since it last asserted.
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(4,4),Register::Access<Register::AccessType::readOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,IdleVal> idle{};
        namespace IdleValC{
            constexpr Register::FieldValue<decltype(idle)::Type,IdleVal::v0> v0{};
            constexpr Register::FieldValue<decltype(idle)::Type,IdleVal::v1> v1{};
        }
        ///Receive Data Register Full Flag
        enum class RdrfVal {
            v0=0x00000000,     ///<The number of datawords in the receive buffer is less than the number indicated by RXWATER.
            v1=0x00000001,     ///<The number of datawords in the receive buffer is equal to or greater than the number indicated by RXWATER at some point in time since this flag was last cleared.
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(5,5),Register::Access<Register::AccessType::readOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,RdrfVal> rdrf{};
        namespace RdrfValC{
            constexpr Register::FieldValue<decltype(rdrf)::Type,RdrfVal::v0> v0{};
            constexpr Register::FieldValue<decltype(rdrf)::Type,RdrfVal::v1> v1{};
        }
        ///Transmit Complete Flag
        enum class TcVal {
            v0=0x00000000,     ///<Transmitter active (sending data, a preamble, or a break).
            v1=0x00000001,     ///<Transmitter idle (transmission activity complete).
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(6,6),Register::Access<Register::AccessType::readOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,TcVal> tc{};
        namespace TcValC{
            constexpr Register::FieldValue<decltype(tc)::Type,TcVal::v0> v0{};
            constexpr Register::FieldValue<decltype(tc)::Type,TcVal::v1> v1{};
        }
        ///Transmit Data Register Empty Flag
        enum class TdreVal {
            v0=0x00000000,     ///<The amount of data in the transmit buffer is greater than the value indicated by TWFIFO[TXWATER].
            v1=0x00000001,     ///<The amount of data in the transmit buffer is less than or equal to the value indicated by TWFIFO[TXWATER] at some point in time since the flag has been cleared.
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(7,7),Register::Access<Register::AccessType::readOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,TdreVal> tdre{};
        namespace TdreValC{
            constexpr Register::FieldValue<decltype(tdre)::Type,TdreVal::v0> v0{};
            constexpr Register::FieldValue<decltype(tdre)::Type,TdreVal::v1> v1{};
        }
    }
    namespace Uart3S2{    ///<UART Status Register 2
        using Addr = Register::Address<0x4006d005,0xffffff00,0x00000000,unsigned char>;
        ///Receiver Active Flag
        enum class RafVal {
            v0=0x00000000,     ///<UART receiver idle/inactive waiting for a start bit.
            v1=0x00000001,     ///<UART receiver active (RxD input not idle).
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(0,0),Register::Access<Register::AccessType::readOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,RafVal> raf{};
        namespace RafValC{
            constexpr Register::FieldValue<decltype(raf)::Type,RafVal::v0> v0{};
            constexpr Register::FieldValue<decltype(raf)::Type,RafVal::v1> v1{};
        }
        ///LIN Break Detection Enable
        enum class LbkdeVal {
            v0=0x00000000,     ///<Break character is detected at length of 10 bit times (C1[M] = 0), 11 (C1[M] = 1 and C4[M10] = 0), or 12 (C1[M] = 1, C4[M10] = 1, and S1[PE] = 1).
            v1=0x00000001,     ///<Break character is detected at length of 11 bits times (if C1[M] = 0 or 12 bits time (if C1[M] = 1).
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(1,1),Register::ReadWriteAccess,LbkdeVal> lbkde{};
        namespace LbkdeValC{
            constexpr Register::FieldValue<decltype(lbkde)::Type,LbkdeVal::v0> v0{};
            constexpr Register::FieldValue<decltype(lbkde)::Type,LbkdeVal::v1> v1{};
        }
        ///Break Transmit Character Length
        enum class Brk13Val {
            v0=0x00000000,     ///<Break character is 10, 11, or 12 bits long.
            v1=0x00000001,     ///<Break character is 13 or 14 bits long.
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(2,2),Register::ReadWriteAccess,Brk13Val> brk13{};
        namespace Brk13ValC{
            constexpr Register::FieldValue<decltype(brk13)::Type,Brk13Val::v0> v0{};
            constexpr Register::FieldValue<decltype(brk13)::Type,Brk13Val::v1> v1{};
        }
        ///Receive Wakeup Idle Detect
        enum class RwuidVal {
            v0=0x00000000,     ///<The S1[IDLE] bit is not set upon detection of an idle character.
            v1=0x00000001,     ///<The S1[IDLE] bit is set upon detection of an idle character.
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(3,3),Register::ReadWriteAccess,RwuidVal> rwuid{};
        namespace RwuidValC{
            constexpr Register::FieldValue<decltype(rwuid)::Type,RwuidVal::v0> v0{};
            constexpr Register::FieldValue<decltype(rwuid)::Type,RwuidVal::v1> v1{};
        }
        ///Receive Data Inversion
        enum class RxinvVal {
            v0=0x00000000,     ///<Receive data is not inverted.
            v1=0x00000001,     ///<Receive data is inverted.
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(4,4),Register::ReadWriteAccess,RxinvVal> rxinv{};
        namespace RxinvValC{
            constexpr Register::FieldValue<decltype(rxinv)::Type,RxinvVal::v0> v0{};
            constexpr Register::FieldValue<decltype(rxinv)::Type,RxinvVal::v1> v1{};
        }
        ///Most Significant Bit First
        enum class MsbfVal {
            v0=0x00000000,     ///<LSB (bit0) is the first bit that is transmitted following the start bit. Further, the first bit received after the start bit is identified as bit0.
            v1=0x00000001,     ///<MSB (bit8, bit7 or bit6) is the first bit that is transmitted following the start bit depending on the setting of C1[M] and C1[PE]. Further, the first bit received after the start bit is identified as bit8, bit7 or bit6 depending on the setting of C1[M] and C1[PE].
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(5,5),Register::ReadWriteAccess,MsbfVal> msbf{};
        namespace MsbfValC{
            constexpr Register::FieldValue<decltype(msbf)::Type,MsbfVal::v0> v0{};
            constexpr Register::FieldValue<decltype(msbf)::Type,MsbfVal::v1> v1{};
        }
        ///RxD Pin Active Edge Interrupt Flag
        enum class RxedgifVal {
            v0=0x00000000,     ///<No active edge on the receive pin has occurred.
            v1=0x00000001,     ///<An active edge on the receive pin has occurred.
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(6,6),Register::ReadWriteAccess,RxedgifVal> rxedgif{};
        namespace RxedgifValC{
            constexpr Register::FieldValue<decltype(rxedgif)::Type,RxedgifVal::v0> v0{};
            constexpr Register::FieldValue<decltype(rxedgif)::Type,RxedgifVal::v1> v1{};
        }
        ///LIN Break Detect Interrupt Flag
        enum class LbkdifVal {
            v0=0x00000000,     ///<No LIN break character has been detected.
            v1=0x00000001,     ///<LIN break character has been detected.
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(7,7),Register::ReadWriteAccess,LbkdifVal> lbkdif{};
        namespace LbkdifValC{
            constexpr Register::FieldValue<decltype(lbkdif)::Type,LbkdifVal::v0> v0{};
            constexpr Register::FieldValue<decltype(lbkdif)::Type,LbkdifVal::v1> v1{};
        }
    }
    namespace Uart3C3{    ///<UART Control Register 3
        using Addr = Register::Address<0x4006d006,0xffffff00,0x00000000,unsigned char>;
        ///Parity Error Interrupt Enable
        enum class PeieVal {
            v0=0x00000000,     ///<PF interrupt requests are disabled.
            v1=0x00000001,     ///<PF interrupt requests are enabled.
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(0,0),Register::ReadWriteAccess,PeieVal> peie{};
        namespace PeieValC{
            constexpr Register::FieldValue<decltype(peie)::Type,PeieVal::v0> v0{};
            constexpr Register::FieldValue<decltype(peie)::Type,PeieVal::v1> v1{};
        }
        ///Framing Error Interrupt Enable
        enum class FeieVal {
            v0=0x00000000,     ///<FE interrupt requests are disabled.
            v1=0x00000001,     ///<FE interrupt requests are enabled.
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(1,1),Register::ReadWriteAccess,FeieVal> feie{};
        namespace FeieValC{
            constexpr Register::FieldValue<decltype(feie)::Type,FeieVal::v0> v0{};
            constexpr Register::FieldValue<decltype(feie)::Type,FeieVal::v1> v1{};
        }
        ///Noise Error Interrupt Enable
        enum class NeieVal {
            v0=0x00000000,     ///<NF interrupt requests are disabled.
            v1=0x00000001,     ///<NF interrupt requests are enabled.
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(2,2),Register::ReadWriteAccess,NeieVal> neie{};
        namespace NeieValC{
            constexpr Register::FieldValue<decltype(neie)::Type,NeieVal::v0> v0{};
            constexpr Register::FieldValue<decltype(neie)::Type,NeieVal::v1> v1{};
        }
        ///Overrun Error Interrupt Enable
        enum class OrieVal {
            v0=0x00000000,     ///<OR interrupts are disabled.
            v1=0x00000001,     ///<OR interrupt requests are enabled.
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(3,3),Register::ReadWriteAccess,OrieVal> orie{};
        namespace OrieValC{
            constexpr Register::FieldValue<decltype(orie)::Type,OrieVal::v0> v0{};
            constexpr Register::FieldValue<decltype(orie)::Type,OrieVal::v1> v1{};
        }
        ///Transmit Data Inversion.
        enum class TxinvVal {
            v0=0x00000000,     ///<Transmit data is not inverted.
            v1=0x00000001,     ///<Transmit data is inverted.
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(4,4),Register::ReadWriteAccess,TxinvVal> txinv{};
        namespace TxinvValC{
            constexpr Register::FieldValue<decltype(txinv)::Type,TxinvVal::v0> v0{};
            constexpr Register::FieldValue<decltype(txinv)::Type,TxinvVal::v1> v1{};
        }
        ///Transmitter Pin Data Direction in Single-Wire mode
        enum class TxdirVal {
            v0=0x00000000,     ///<TXD pin is an input in single-wire mode.
            v1=0x00000001,     ///<TXD pin is an output in single-wire mode.
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(5,5),Register::ReadWriteAccess,TxdirVal> txdir{};
        namespace TxdirValC{
            constexpr Register::FieldValue<decltype(txdir)::Type,TxdirVal::v0> v0{};
            constexpr Register::FieldValue<decltype(txdir)::Type,TxdirVal::v1> v1{};
        }
        ///Transmit Bit 8
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(6,6),Register::ReadWriteAccess,unsigned> t8{};
        ///Received Bit 8
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(7,7),Register::Access<Register::AccessType::readOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,unsigned> r8{};
    }
    namespace Uart3D{    ///<UART Data Register
        using Addr = Register::Address<0x4006d007,0xffffff00,0x00000000,unsigned char>;
        ///no description available
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(7,0),Register::ReadWriteAccess,unsigned> rt{};
    }
    namespace Uart3Ma1{    ///<UART Match Address Registers 1
        using Addr = Register::Address<0x4006d008,0xffffff00,0x00000000,unsigned char>;
        ///Match Address
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(7,0),Register::ReadWriteAccess,unsigned> ma{};
    }
    namespace Uart3Ma2{    ///<UART Match Address Registers 2
        using Addr = Register::Address<0x4006d009,0xffffff00,0x00000000,unsigned char>;
        ///Match Address
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(7,0),Register::ReadWriteAccess,unsigned> ma{};
    }
    namespace Uart3C4{    ///<UART Control Register 4
        using Addr = Register::Address<0x4006d00a,0xffffff00,0x00000000,unsigned char>;
        ///Baud Rate Fine Adjust
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(4,0),Register::ReadWriteAccess,unsigned> brfa{};
        ///10-bit Mode select
        enum class M10Val {
            v0=0x00000000,     ///<The parity bit is the ninth bit in the serial transmission.
            v1=0x00000001,     ///<The parity bit is the tenth bit in the serial transmission.
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(5,5),Register::ReadWriteAccess,M10Val> m10{};
        namespace M10ValC{
            constexpr Register::FieldValue<decltype(m10)::Type,M10Val::v0> v0{};
            constexpr Register::FieldValue<decltype(m10)::Type,M10Val::v1> v1{};
        }
        ///Match Address Mode Enable 2
        enum class Maen2Val {
            v0=0x00000000,     ///<All data received is transferred to the data buffer if MAEN1 is cleared.
            v1=0x00000001,     ///<All data received with the most significant bit cleared, is discarded. All data received with the most significant bit set, is compared with contents of MA2 register. If no match occurs, the data is discarded. If match occurs, data is transferred to the data buffer.This bit must be cleared when C7816[ISO7816E] is set/enabled.
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(6,6),Register::ReadWriteAccess,Maen2Val> maen2{};
        namespace Maen2ValC{
            constexpr Register::FieldValue<decltype(maen2)::Type,Maen2Val::v0> v0{};
            constexpr Register::FieldValue<decltype(maen2)::Type,Maen2Val::v1> v1{};
        }
        ///Match Address Mode Enable 1
        enum class Maen1Val {
            v0=0x00000000,     ///<All data received is transferred to the data buffer if MAEN2 is cleared.
            v1=0x00000001,     ///<All data received with the most significant bit cleared, is discarded. All data received with the most significant bit set, is compared with contents of MA1 register. If no match occurs, the data is discarded. If match occurs, data is transferred to the data buffer.This bit must be cleared when C7816[ISO7816E] is set/enabled.
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(7,7),Register::ReadWriteAccess,Maen1Val> maen1{};
        namespace Maen1ValC{
            constexpr Register::FieldValue<decltype(maen1)::Type,Maen1Val::v0> v0{};
            constexpr Register::FieldValue<decltype(maen1)::Type,Maen1Val::v1> v1{};
        }
    }
    namespace Uart3C5{    ///<UART Control Register 5
        using Addr = Register::Address<0x4006d00b,0xffffff5f,0x00000000,unsigned char>;
        ///Receiver Full DMA Select
        enum class RdmasVal {
            v0=0x00000000,     ///<If C2[RIE] is set and the S1[RDRF] flag is set, the RDFR interrupt request signal is asserted to request interrupt service.
            v1=0x00000001,     ///<If C2[RIE] is set and the S1[RDRF] flag is set, the RDRF DMA request signal is asserted to request a DMA transfer.
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(5,5),Register::ReadWriteAccess,RdmasVal> rdmas{};
        namespace RdmasValC{
            constexpr Register::FieldValue<decltype(rdmas)::Type,RdmasVal::v0> v0{};
            constexpr Register::FieldValue<decltype(rdmas)::Type,RdmasVal::v1> v1{};
        }
        ///Transmitter DMA Select
        enum class TdmasVal {
            v0=0x00000000,     ///<If C2[TIE] is set and the S1[TDRE] flag is set, the TDRE interrupt request signal is asserted to request interrupt service.
            v1=0x00000001,     ///<If C2[TIE] is set and the S1[TDRE] flag is set, the TDRE DMA request signal is asserted to request a DMA transfer.
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(7,7),Register::ReadWriteAccess,TdmasVal> tdmas{};
        namespace TdmasValC{
            constexpr Register::FieldValue<decltype(tdmas)::Type,TdmasVal::v0> v0{};
            constexpr Register::FieldValue<decltype(tdmas)::Type,TdmasVal::v1> v1{};
        }
    }
    namespace Uart3Ed{    ///<UART Extended Data Register
        using Addr = Register::Address<0x4006d00c,0xffffff3f,0x00000000,unsigned char>;
        ///no description available
        enum class ParityeVal {
            v0=0x00000000,     ///<The dataword was received without a parity error.
            v1=0x00000001,     ///<The dataword was received with a parity error.
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(6,6),Register::Access<Register::AccessType::readOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,ParityeVal> paritye{};
        namespace ParityeValC{
            constexpr Register::FieldValue<decltype(paritye)::Type,ParityeVal::v0> v0{};
            constexpr Register::FieldValue<decltype(paritye)::Type,ParityeVal::v1> v1{};
        }
        ///no description available
        enum class NoisyVal {
            v0=0x00000000,     ///<The dataword was received without noise.
            v1=0x00000001,     ///<The data was received with noise.
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(7,7),Register::Access<Register::AccessType::readOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,NoisyVal> noisy{};
        namespace NoisyValC{
            constexpr Register::FieldValue<decltype(noisy)::Type,NoisyVal::v0> v0{};
            constexpr Register::FieldValue<decltype(noisy)::Type,NoisyVal::v1> v1{};
        }
    }
    namespace Uart3Modem{    ///<UART Modem Register
        using Addr = Register::Address<0x4006d00d,0xfffffff0,0x00000000,unsigned char>;
        ///Transmitter clear-to-send enable
        enum class TxctseVal {
            v0=0x00000000,     ///<CTS has no effect on the transmitter.
            v1=0x00000001,     ///<Enables clear-to-send operation. The transmitter checks the state of CTS each time it is ready to send a character. If CTS is asserted, the character is sent. If CTS is deasserted, the signal TXD remains in the mark state and transmission is delayed until CTS is asserted. Changes in CTS as a character is being sent do not affect its transmission.
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(0,0),Register::ReadWriteAccess,TxctseVal> txctse{};
        namespace TxctseValC{
            constexpr Register::FieldValue<decltype(txctse)::Type,TxctseVal::v0> v0{};
            constexpr Register::FieldValue<decltype(txctse)::Type,TxctseVal::v1> v1{};
        }
        ///Transmitter request-to-send enable
        enum class TxrtseVal {
            v0=0x00000000,     ///<The transmitter has no effect on RTS.
            v1=0x00000001,     ///<When a character is placed into an empty transmitter data buffer(FIFO), RTS asserts one bit time before the start bit is transmitted. RTS deasserts one bit time after all characters in the transmitter data buffer(FIFO) and shift register are completely sent, including the last stop bit.
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(1,1),Register::ReadWriteAccess,TxrtseVal> txrtse{};
        namespace TxrtseValC{
            constexpr Register::FieldValue<decltype(txrtse)::Type,TxrtseVal::v0> v0{};
            constexpr Register::FieldValue<decltype(txrtse)::Type,TxrtseVal::v1> v1{};
        }
        ///Transmitter request-to-send polarity
        enum class TxrtspolVal {
            v0=0x00000000,     ///<Transmitter RTS is active low.
            v1=0x00000001,     ///<Transmitter RTS is active high.
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(2,2),Register::ReadWriteAccess,TxrtspolVal> txrtspol{};
        namespace TxrtspolValC{
            constexpr Register::FieldValue<decltype(txrtspol)::Type,TxrtspolVal::v0> v0{};
            constexpr Register::FieldValue<decltype(txrtspol)::Type,TxrtspolVal::v1> v1{};
        }
        ///Receiver request-to-send enable
        enum class RxrtseVal {
            v0=0x00000000,     ///<The receiver has no effect on RTS.
            v1=0x00000001,     ///<RTS is deasserted if the number of characters in the receiver data register (FIFO) is equal to or greater than RWFIFO[RXWATER]. RTS is asserted when the number of characters in the receiver data register (FIFO) is less than RWFIFO[RXWATER].
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(3,3),Register::ReadWriteAccess,RxrtseVal> rxrtse{};
        namespace RxrtseValC{
            constexpr Register::FieldValue<decltype(rxrtse)::Type,RxrtseVal::v0> v0{};
            constexpr Register::FieldValue<decltype(rxrtse)::Type,RxrtseVal::v1> v1{};
        }
    }
    namespace Uart3Ir{    ///<UART Infrared Register
        using Addr = Register::Address<0x4006d00e,0xfffffff8,0x00000000,unsigned char>;
        ///Transmitter narrow pulse
        enum class TnpVal {
            v00=0x00000000,     ///<3/16.
            v01=0x00000001,     ///<1/16.
            v10=0x00000002,     ///<1/32.
            v11=0x00000003,     ///<1/4.
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(1,0),Register::ReadWriteAccess,TnpVal> tnp{};
        namespace TnpValC{
            constexpr Register::FieldValue<decltype(tnp)::Type,TnpVal::v00> v00{};
            constexpr Register::FieldValue<decltype(tnp)::Type,TnpVal::v01> v01{};
            constexpr Register::FieldValue<decltype(tnp)::Type,TnpVal::v10> v10{};
            constexpr Register::FieldValue<decltype(tnp)::Type,TnpVal::v11> v11{};
        }
        ///Infrared enable
        enum class IrenVal {
            v0=0x00000000,     ///<IR disabled.
            v1=0x00000001,     ///<IR enabled.
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(2,2),Register::ReadWriteAccess,IrenVal> iren{};
        namespace IrenValC{
            constexpr Register::FieldValue<decltype(iren)::Type,IrenVal::v0> v0{};
            constexpr Register::FieldValue<decltype(iren)::Type,IrenVal::v1> v1{};
        }
    }
    namespace Uart3Pfifo{    ///<UART FIFO Parameters
        using Addr = Register::Address<0x4006d010,0xffffff00,0x00000000,unsigned char>;
        ///Receive FIFO. Buffer Depth
        enum class RxfifosizeVal {
            v000=0x00000000,     ///<Receive FIFO/Buffer Depth = 1 Dataword.
            v001=0x00000001,     ///<Receive FIFO/Buffer Depth = 4 Datawords.
            v010=0x00000002,     ///<Receive FIFO/Buffer Depth = 8 Datawords.
            v011=0x00000003,     ///<Receive FIFO/Buffer Depth = 16 Datawords.
            v100=0x00000004,     ///<Receive FIFO/Buffer Depth = 32 Datawords.
            v101=0x00000005,     ///<Receive FIFO/Buffer Depth = 64 Datawords.
            v110=0x00000006,     ///<Receive FIFO/Buffer Depth = 128 Datawords.
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(2,0),Register::Access<Register::AccessType::readOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,RxfifosizeVal> rxfifosize{};
        namespace RxfifosizeValC{
            constexpr Register::FieldValue<decltype(rxfifosize)::Type,RxfifosizeVal::v000> v000{};
            constexpr Register::FieldValue<decltype(rxfifosize)::Type,RxfifosizeVal::v001> v001{};
            constexpr Register::FieldValue<decltype(rxfifosize)::Type,RxfifosizeVal::v010> v010{};
            constexpr Register::FieldValue<decltype(rxfifosize)::Type,RxfifosizeVal::v011> v011{};
            constexpr Register::FieldValue<decltype(rxfifosize)::Type,RxfifosizeVal::v100> v100{};
            constexpr Register::FieldValue<decltype(rxfifosize)::Type,RxfifosizeVal::v101> v101{};
            constexpr Register::FieldValue<decltype(rxfifosize)::Type,RxfifosizeVal::v110> v110{};
        }
        ///Receive FIFO Enable
        enum class RxfeVal {
            v0=0x00000000,     ///<Receive FIFO is not enabled. Buffer is depth 1. (Legacy support)
            v1=0x00000001,     ///<Receive FIFO is enabled. Buffer is depth indicted by RXFIFOSIZE.
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(3,3),Register::ReadWriteAccess,RxfeVal> rxfe{};
        namespace RxfeValC{
            constexpr Register::FieldValue<decltype(rxfe)::Type,RxfeVal::v0> v0{};
            constexpr Register::FieldValue<decltype(rxfe)::Type,RxfeVal::v1> v1{};
        }
        ///Transmit FIFO. Buffer Depth
        enum class TxfifosizeVal {
            v000=0x00000000,     ///<Transmit FIFO/Buffer Depth = 1 Dataword.
            v001=0x00000001,     ///<Transmit FIFO/Buffer Depth = 4 Datawords.
            v010=0x00000002,     ///<Transmit FIFO/Buffer Depth = 8 Datawords.
            v011=0x00000003,     ///<Transmit FIFO/Buffer Depth = 16 Datawords.
            v100=0x00000004,     ///<Transmit FIFO/Buffer Depth = 32 Datawords.
            v101=0x00000005,     ///<Transmit FIFO/Buffer Depth = 64 Datawords.
            v110=0x00000006,     ///<Transmit FIFO/Buffer Depth = 128 Datawords.
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(6,4),Register::Access<Register::AccessType::readOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,TxfifosizeVal> txfifosize{};
        namespace TxfifosizeValC{
            constexpr Register::FieldValue<decltype(txfifosize)::Type,TxfifosizeVal::v000> v000{};
            constexpr Register::FieldValue<decltype(txfifosize)::Type,TxfifosizeVal::v001> v001{};
            constexpr Register::FieldValue<decltype(txfifosize)::Type,TxfifosizeVal::v010> v010{};
            constexpr Register::FieldValue<decltype(txfifosize)::Type,TxfifosizeVal::v011> v011{};
            constexpr Register::FieldValue<decltype(txfifosize)::Type,TxfifosizeVal::v100> v100{};
            constexpr Register::FieldValue<decltype(txfifosize)::Type,TxfifosizeVal::v101> v101{};
            constexpr Register::FieldValue<decltype(txfifosize)::Type,TxfifosizeVal::v110> v110{};
        }
        ///Transmit FIFO Enable
        enum class TxfeVal {
            v0=0x00000000,     ///<Transmit FIFO is not enabled. Buffer is depth 1. (Legacy support).
            v1=0x00000001,     ///<Transmit FIFO is enabled. Buffer is depth indicted by TXFIFOSIZE.
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(7,7),Register::ReadWriteAccess,TxfeVal> txfe{};
        namespace TxfeValC{
            constexpr Register::FieldValue<decltype(txfe)::Type,TxfeVal::v0> v0{};
            constexpr Register::FieldValue<decltype(txfe)::Type,TxfeVal::v1> v1{};
        }
    }
    namespace Uart3Cfifo{    ///<UART FIFO Control Register
        using Addr = Register::Address<0x4006d011,0xffffff3c,0x00000000,unsigned char>;
        ///Receive FIFO Underflow Interrupt Enable
        enum class RxufeVal {
            v0=0x00000000,     ///<RXUF flag does not generate an interrupt to the host.
            v1=0x00000001,     ///<RXUF flag generates an interrupt to the host.
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(0,0),Register::ReadWriteAccess,RxufeVal> rxufe{};
        namespace RxufeValC{
            constexpr Register::FieldValue<decltype(rxufe)::Type,RxufeVal::v0> v0{};
            constexpr Register::FieldValue<decltype(rxufe)::Type,RxufeVal::v1> v1{};
        }
        ///Transmit FIFO Overflow Interrupt Enable
        enum class TxofeVal {
            v0=0x00000000,     ///<TXOF flag does not generate an interrupt to the host.
            v1=0x00000001,     ///<TXOF flag generates an interrupt to the host.
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(1,1),Register::ReadWriteAccess,TxofeVal> txofe{};
        namespace TxofeValC{
            constexpr Register::FieldValue<decltype(txofe)::Type,TxofeVal::v0> v0{};
            constexpr Register::FieldValue<decltype(txofe)::Type,TxofeVal::v1> v1{};
        }
        ///Receive FIFO/Buffer Flush
        enum class RxflushVal {
            v0=0x00000000,     ///<No flush operation occurs.
            v1=0x00000001,     ///<All data in the receive FIFO/buffer is cleared out.
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(6,6),Register::Access<Register::AccessType::writeOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,RxflushVal> rxflush{};
        namespace RxflushValC{
            constexpr Register::FieldValue<decltype(rxflush)::Type,RxflushVal::v0> v0{};
            constexpr Register::FieldValue<decltype(rxflush)::Type,RxflushVal::v1> v1{};
        }
        ///Transmit FIFO/Buffer Flush
        enum class TxflushVal {
            v0=0x00000000,     ///<No flush operation occurs.
            v1=0x00000001,     ///<All data in the transmit FIFO/Buffer is cleared out.
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(7,7),Register::Access<Register::AccessType::writeOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,TxflushVal> txflush{};
        namespace TxflushValC{
            constexpr Register::FieldValue<decltype(txflush)::Type,TxflushVal::v0> v0{};
            constexpr Register::FieldValue<decltype(txflush)::Type,TxflushVal::v1> v1{};
        }
    }
    namespace Uart3Sfifo{    ///<UART FIFO Status Register
        using Addr = Register::Address<0x4006d012,0xffffff3c,0x00000000,unsigned char>;
        ///Receiver Buffer Underflow Flag
        enum class RxufVal {
            v0=0x00000000,     ///<No receive buffer underflow has occurred since the last time the flag was cleared.
            v1=0x00000001,     ///<At least one receive buffer underflow has occurred since the last time the flag was cleared.
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(0,0),Register::ReadWriteAccess,RxufVal> rxuf{};
        namespace RxufValC{
            constexpr Register::FieldValue<decltype(rxuf)::Type,RxufVal::v0> v0{};
            constexpr Register::FieldValue<decltype(rxuf)::Type,RxufVal::v1> v1{};
        }
        ///Transmitter Buffer Overflow Flag
        enum class TxofVal {
            v0=0x00000000,     ///<No transmit buffer overflow has occurred since the last time the flag was cleared.
            v1=0x00000001,     ///<At least one transmit buffer overflow has occurred since the last time the flag was cleared.
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(1,1),Register::ReadWriteAccess,TxofVal> txof{};
        namespace TxofValC{
            constexpr Register::FieldValue<decltype(txof)::Type,TxofVal::v0> v0{};
            constexpr Register::FieldValue<decltype(txof)::Type,TxofVal::v1> v1{};
        }
        ///Receive Buffer/FIFO Empty
        enum class RxemptVal {
            v0=0x00000000,     ///<Receive buffer is not empty.
            v1=0x00000001,     ///<Receive buffer is empty.
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(6,6),Register::Access<Register::AccessType::readOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,RxemptVal> rxempt{};
        namespace RxemptValC{
            constexpr Register::FieldValue<decltype(rxempt)::Type,RxemptVal::v0> v0{};
            constexpr Register::FieldValue<decltype(rxempt)::Type,RxemptVal::v1> v1{};
        }
        ///Transmit Buffer/FIFO Empty
        enum class TxemptVal {
            v0=0x00000000,     ///<Transmit buffer is not empty.
            v1=0x00000001,     ///<Transmit buffer is empty.
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(7,7),Register::Access<Register::AccessType::readOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,TxemptVal> txempt{};
        namespace TxemptValC{
            constexpr Register::FieldValue<decltype(txempt)::Type,TxemptVal::v0> v0{};
            constexpr Register::FieldValue<decltype(txempt)::Type,TxemptVal::v1> v1{};
        }
    }
    namespace Uart3Twfifo{    ///<UART FIFO Transmit Watermark
        using Addr = Register::Address<0x4006d013,0xffffff00,0x00000000,unsigned char>;
        ///Transmit Watermark
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(7,0),Register::ReadWriteAccess,unsigned> txwater{};
    }
    namespace Uart3Tcfifo{    ///<UART FIFO Transmit Count
        using Addr = Register::Address<0x4006d014,0xffffff00,0x00000000,unsigned char>;
        ///Transmit Counter
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(7,0),Register::Access<Register::AccessType::readOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,unsigned> txcount{};
    }
    namespace Uart3Rwfifo{    ///<UART FIFO Receive Watermark
        using Addr = Register::Address<0x4006d015,0xffffff00,0x00000000,unsigned char>;
        ///Receive Watermark
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(7,0),Register::ReadWriteAccess,unsigned> rxwater{};
    }
    namespace Uart3Rcfifo{    ///<UART FIFO Receive Count
        using Addr = Register::Address<0x4006d016,0xffffff00,0x00000000,unsigned char>;
        ///Receive Counter
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(7,0),Register::Access<Register::AccessType::readOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,unsigned> rxcount{};
    }
}

{'repo_name': 'kvasir-io/Kvasir', 'stars': '310', 'repo_language': 'C++', 'file_name': 'SC1.hpp', 'mime_type': 'text/x-c++', 'hash': -7073545611523474122, 'source_dataset': 'data'}


using Bridge.Contract;
using Bridge.Contract.Constants;
using ICSharpCode.NRefactory.CSharp;
using Object.Net.Utilities;
using System.Collections.Generic;
using System.Linq;
using ICSharpCode.NRefactory.TypeSystem;

namespace Bridge.Translator.TypeScript
{
    public partial class ConstructorBlock : TypeScriptBlock
    {
        public ConstructorBlock(IEmitter emitter, ITypeInfo typeInfo)
            : base(emitter, typeInfo.TypeDeclaration)
        {
            this.Emitter = emitter;
            this.TypeInfo = typeInfo;
        }

        public ITypeInfo TypeInfo
        {
            get;
            set;
        }

        protected override void DoEmit()
        {
            this.EmitCtorForInstantiableClass();
        }

        protected virtual void EmitCtorForInstantiableClass()
        {
            var typeDef = this.Emitter.GetTypeDefinition();
            string name = this.Emitter.Validator.GetCustomTypeName(typeDef, this.Emitter, true, false);

            if (name.IsEmpty())
            {
                name = BridgeTypes.ToTypeScriptName(this.TypeInfo.Type, this.Emitter, false, true);
            }

            if (this.TypeInfo.Ctors.Count == 0)
            {
                this.Write("new ");
                this.WriteOpenCloseParentheses();
                this.WriteColon();
                this.Write(name);
                this.WriteSemiColon();
                this.WriteNewLine();
            }
            else if (this.TypeInfo.Ctors.Count == 1)
            {
                var ctor = this.TypeInfo.Ctors.First();
                if (!ctor.HasModifier(Modifiers.Public))
                {
                    return;
                }

                XmlToJsDoc.EmitComment(this, ctor);

                this.Write("new ");
                this.EmitMethodParameters(ctor.Parameters, ctor);
                this.WriteColon();
                this.Write(name);
                this.WriteSemiColon();
                this.WriteNewLine();
            }
            else
            {
                foreach (var ctor in this.TypeInfo.Ctors)
                {
                    if (!ctor.HasModifier(Modifiers.Public))
                    {
                        continue;
                    }

                    if (ctor.Parameters.Count == 0)
                    {
                        XmlToJsDoc.EmitComment(this, ctor);
                        this.Write("new ()");
                        this.WriteColon();
                        this.Write(name);
                        this.WriteSemiColon();
                        this.WriteNewLine();
                    }

                    XmlToJsDoc.EmitComment(this, ctor);
                    var ctorName = JS.Funcs.CONSTRUCTOR;

                    if (this.TypeInfo.Ctors.Count > 1 && ctor.Parameters.Count > 0)
                    {
                        var overloads = OverloadsCollection.Create(this.Emitter, ctor);
                        ctorName = overloads.GetOverloadName();
                    }

                    this.Write(ctorName);
                    this.WriteColon();
                    this.BeginBlock();

                    this.WriteNew();
                    this.EmitMethodParameters(ctor.Parameters, ctor);
                    this.WriteColon();

                    this.Write(name);
                    this.WriteNewLine();
                    this.EndBlock();

                    this.WriteSemiColon();
                    this.WriteNewLine();
                }
            }
        }

        protected virtual void EmitMethodParameters(IEnumerable<ParameterDeclaration> declarations, AstNode context)
        {
            this.WriteOpenParentheses();
            bool needComma = false;

            foreach (var p in declarations)
            {
                var name = this.Emitter.GetParameterName(p);

                if (needComma)
                {
                    this.WriteComma();
                }

                needComma = true;
                this.Write(name);
                this.WriteColon();
                name = BridgeTypes.ToTypeScriptName(p.Type, this.Emitter);
                this.Write(name);

                var resolveResult = this.Emitter.Resolver.ResolveNode(p.Type, this.Emitter);
                if (resolveResult != null && (resolveResult.Type.IsReferenceType.HasValue && resolveResult.Type.IsReferenceType.Value || resolveResult.Type.IsKnownType(KnownTypeCode.NullableOfT)))
                {
                    this.Write(" | null");
                }
            }

            this.WriteCloseParentheses();
        }
    }
}

{'repo_name': 'bridgedotnet/Bridge', 'stars': '2083', 'repo_language': 'C#', 'file_name': 'AssemblyInfo.cs', 'mime_type': 'text/plain', 'hash': -3276204478000066020, 'source_dataset': 'data'}


% VL_LOCALMAX  Find local maximizers
%   SEL=VL_LOCALMAX(F) returns the indexes of the local maximizers of
%   the Q-dimensional array F.
%
%   A local maximizer is an array element whose value is larger than
%   the value of all its neighbors.  The neighbors of an element
%   i1...iQ have subscripts j1...jQ such that iq-1 <= jq <= iq
%   (excluding i1...iQ itself).  For example, if Q=1 the neighbors of
%   an element are its predecessor and successor in the linear order;
%   if Q=2, its neighbors are the elements immediately to its north,
%   south, west, est, north-west, north-est, south-west and south-est
%   (8-neighborhood).
%
%   Points on the boundary of F are ignored (and never selected as
%   local maximizers).
%
%   SEL=VL_LOCALMAX(F,THRESH) accepts an element as a mazimizer only
%   if it is not smaller than THRESH.
%
%   SEL=VL_LOCALMAX(F,THRESH,P) looks for neighbors only in the first
%   P dimensions of the Q-dimensional array F. This allows to process
%   F in ``slices''.
%
%   Remark::
%     Matrices (2-array) with a singleton dimension are
%     interpreted as vectors (1-array). So for example VL_LOCALMAX([0 1
%     0]) and VL_LOCALMAX([0 1 0]') both return 2 as an aswer. However,
%     if [0 1 0] is to be interpreted as a 1x2 matrix, then the
%     correct answer is the empty set, as all elements are on the
%     boundary. Unfortunately MATLAB does not distinguish between
%     vectors and 2-matrices with a singleton dimension.  To forece
%     the interpretation of all matrices as 2-arrays, use
%     VL_LOCALMAX(F,TRESH,2) (but note that in this case the result is
%     always empty!).
%
%   See also: VL_HELP().

% Copyright (C) 2007-12 Andrea Vedaldi and Brian Fulkerson.
% All rights reserved.
%
% This file is part of the VLFeat library and is made available under
% the terms of the BSD license (see the COPYING file).

% TODO: Companion REFINELOCALMAX
% TODO: Do something smarter at boundaries

{'repo_name': 'jianxiongxiao/ProfXkit', 'stars': '102', 'repo_language': 'Matlab', 'file_name': 'README', 'mime_type': 'text/plain', 'hash': 6633123628916947449, 'source_dataset': 'data'}


# Accounts Bot

This demo bot serves account owner information for a fictional sales team. This code sample
shows how create a bot that looks up information from a [Google Sheet][data_sheet] and served by a
[Google Cloud Function][gcf]. With this bot, a user who requests an account owner's information will
either receive a card with contact info or an option ensure the data is up-to-date if the requested
account could not be found.

![Acme-Lookup](https://github.com/gsuitedevs/hangouts-chat-samples/blob/master/node/accounts-bot/assets/AcmeLookup.png)

[gcf]: https://cloud.google.com/functions
[data_sheet]: https://docs.google.com/spreadsheets/d/1kxW15ZI48mh4KkvgsMpg7gInmEQmyKYRnZdbUOSMRnU/copy

## Prerequisites

1. The [Google Cloud SDK][cloud_sdk] and `gcloud` set up on your machine.
1. Please be sure to have completed or understood the concepts in the Hangouts Chat
Google Cloud Functions [quickstart guide][gcf_bot] first.

[cloud_sdk]: https://cloud.google.com/deployment-manager/docs/step-by-step-guide/installation-and-setup
[gcf_bot]: https://developers.google.com/hangouts/chat/quickstart/gcf-bot

## Set up instructions

1. Make a copy of the [data sheet][data_sheet] in your Google Drive.
1. Create a new Node.js project in your working directory with:

`npm init`

1. Copy the code in index.js to your working directory.
1. Install the googleapis library to access the Sheets API:

`npm install googleapis --save`

### Set up a Google Cloud Project (if needed)

1. [Create a new project][new_project] in the Google Cloud Developer Console.
Name it "AccountsBot", select a **Billing Account** if prompted, and
click **CREATE**. More information on how to setup billing [here][billing].
1. When the project creation is complete a notification appears in the
upper-right of the page. Click on the **Create Project: AccountsBot** entry
to open the project.
1. Open the [**OAuth consent screen**][consent_screen] settings page for the
project.
1. In the field **Application name** enter "AccountsBot" and click the
**Save** button at the bottom.
1. Open the [**Sheets API**][library_sheets] page in the API library and click
the **ENABLE** button.
1. Open the [**Project settings**][project_settings] page for the project.
1. Copy the value listed under **Project number**.

[new_project]: https://console.cloud.google.com/projectcreate
[billing]: https://cloud.google.com/free/docs/gcp-free-tier
[consent_screen]: https://console.cloud.google.com/apis/credentials/consent
[library_sheets]: https://console.cloud.google.com/apis/library/sheets
[project_settings]: https://console.cloud.google.com/iam-admin/settings

### Deploying the Cloud Function

1. In your working directory, deploy the Cloud function with the following command:
`gcloud functions deploy accountsBot --runtime nodejs8 --trigger-http`

### Set the permissions on the data

1. The Cloud Function at runtime will run as your GCP project's AppEngine Default
Service Account. Read more [here][functions_iam]. In the Cloud Console, navigate
to your project's [service accounts][service_accounts] and copy your AppEngine
Service Account address which should be in this format:

`PROJECT_ID@appspot.gserviceaccount.com`

  1. If one is not already present, trigger your Cloud Function from the Functions Console.
  1. Navigate back to your service accounts and it should be present.
1. Open your data sheet and give this address view-only permissions.

[cloud_console]: https://console.cloud.google.com/
[service_accounts]: https://console.cloud.google.com/iam-admin/serviceaccounts
[functions_iam]: https://cloud.google.com/functions/docs/concepts/iam

### Publish the bot to Hangouts Chat

1.  Back in the Cloud Console, open the
    [**Hangouts Chat API**][library_chat] page in the API library and click the
    **ENABLE** button.
1.  Once the API is enabled, on click the **Configuration** tab.
1.  In the Configuration tab, do the following:
    1.  In the **Bot name** box, enter "AccountsBot".
    1.  In the **Avatar URL box**, enter `https://www.gstatic.com/images/icons/material/system_gm/1x/badge_black_18dp.png`.
    1.  In the **Description box**, enter "Easy account owners look up".
    1.  Under **Functionality**, select all options.
    1.  Under **Connection settings**, select **Bot Url** and paste
        your the URL for the Cloud Function trigger into the box.
    1.  Under **Permissions**, select **Specific people and group in your
        domain**. In the text box under the drop-down menu, enter your email
        address.
    1.  Click Save changes.
1.  After you save your changes, verify that the status on the Hangouts Chat API
    page shows the Bot Status to be **LIVE – available to users**.

[library_chat]: https://console.cloud.google.com/apis/library/chat.googleapis.com

## Test the bot

1.  Open [Hangouts Chat][hangouts_chat].
1.  Click **Find people, rooms, bots > Message a bot**.
1.  From the list, select the **AccountsBot** that you created.
1.  Send the message "Acme" to the bot, you should receive a card shown above.
1.  Send the message "foo", you should receive the default card:
![Foo-Lookup](https://github.com/gsuitedevs/hangouts-chat-samples/blob/master/node/accounts-bot/assets/FooLookup.png)

[hangouts_chat]: https://chat.google.com

{'repo_name': 'gsuitedevs/hangouts-chat-samples', 'stars': '235', 'repo_language': 'Python', 'file_name': 'README.md', 'mime_type': 'text/plain', 'hash': 4441065458868948300, 'source_dataset': 'data'}


<component name="ProjectRunConfigurationManager">
  <configuration default="false" name="MPS Remote" type="Remote">
    <module name="mps-workbench" />
    <option name="USE_SOCKET_TRANSPORT" value="true" />
    <option name="SERVER_MODE" value="false" />
    <option name="SHMEM_ADDRESS" />
    <option name="HOST" value="localhost" />
    <option name="PORT" value="5003" />
    <option name="AUTO_RESTART" value="false" />
    <RunnerSettings RunnerId="Debug">
      <option name="DEBUG_PORT" value="5003" />
      <option name="LOCAL" value="false" />
    </RunnerSettings>
    <method v="2" />
  </configuration>
</component>

{'repo_name': 'JetBrains/MPS', 'stars': '1070', 'repo_language': 'Java', 'file_name': 'LanguageAspectsEP_extension.java', 'mime_type': 'text/x-java', 'hash': -6071645367172387312, 'source_dataset': 'data'}


package top.trumeet.mipushframework.utils;

import android.support.v7.widget.LinearLayoutManager;
import android.support.v7.widget.RecyclerView;
import android.util.Log;

public abstract class OnLoadMoreListener extends RecyclerView.OnScrollListener {

    private LinearLayoutManager layoutManager;
    private int itemCount, lastPosition, lastItemCount;

    public abstract void onLoadMore();

    @Override
    public void onScrolled(RecyclerView recyclerView, int dx, int dy) {
        if (recyclerView.getLayoutManager() instanceof LinearLayoutManager) {
            layoutManager = (LinearLayoutManager) recyclerView.getLayoutManager();

            itemCount = layoutManager.getItemCount();
            lastPosition = layoutManager.findLastCompletelyVisibleItemPosition();
        } else {
            Log.e("OnLoadMoreListener", "The OnLoadMoreListener only support LinearLayoutManager");
            return;
        }

        if (lastItemCount != itemCount && (lastPosition > itemCount - 3)) {
            lastItemCount = itemCount;
            this.onLoadMore();
        }
    }
}

{'repo_name': 'MiPushFramework/MiPushFramework', 'stars': '1630', 'repo_language': 'Java', 'file_name': 'CondomContextBasicSemanticTest.java', 'mime_type': 'text/x-java', 'hash': -2512651799836676204, 'source_dataset': 'data'}


/*
**  ClanLib SDK
**  Copyright (c) 1997-2016 The ClanLib Team
**
**  This software is provided 'as-is', without any express or implied
**  warranty.  In no event will the authors be held liable for any damages
**  arising from the use of this software.
**
**  Permission is granted to anyone to use this software for any purpose,
**  including commercial applications, and to alter it and redistribute it
**  freely, subject to the following restrictions:
**
**  1. The origin of this software must not be misrepresented; you must not
**     claim that you wrote the original software. If you use this software
**     in a product, an acknowledgment in the product documentation would be
**     appreciated but is not required.
**  2. Altered source versions must be plainly marked as such, and must not be
**     misrepresented as being the original software.
**  3. This notice may not be removed or altered from any source distribution.
**
**  Note: Some of the libraries ClanLib may link to may have additional
**  requirements or restrictions.
**
**  File Author(s):
**
**    Magnus Norddahl
*/

#include "Core/precomp.h"
#include "zip_iodevice_fileentry.h"
#include "zip_file_entry_impl.h"
#include "zip_compression_method.h"
#include "zip_flags.h"
#include "API/Core/IOData/file.h"
#include "API/Core/Math/cl_math.h"
#include "API/Core/Text/string_format.h"

namespace clan
{
	ZipIODevice_FileEntry::ZipIODevice_FileEntry(IODevice iodevice, const ZipFileEntry &entry)
		: iodevice(iodevice), file_entry(entry), zstream_open(false), peeked_data(0)
	{
		init();
	}

	ZipIODevice_FileEntry::~ZipIODevice_FileEntry()
	{
		deinit();
	}

	size_t ZipIODevice_FileEntry::get_size() const
	{
		return size_t(file_header.uncompressed_size);
	}

	size_t ZipIODevice_FileEntry::get_position() const
	{
		return size_t(pos);
	}

	size_t ZipIODevice_FileEntry::send(const void *data, size_t len, bool send_all)
	{
		throw Exception("Read-only device.");
	}

	size_t ZipIODevice_FileEntry::receive(void *buffer, size_t size, bool receive_all)
	{
		if (size == 0)
			return 0;
		if (peeked_data.get_size() > 0)
		{
			size_t peek_amount = min(size, peeked_data.get_size());
			memcpy(buffer, peeked_data.get_data(), peek_amount);
			memmove(peeked_data.get_data(), peeked_data.get_data() + peek_amount, peeked_data.get_size() - peek_amount);
			peeked_data.set_size(peeked_data.get_size() - peek_amount);
			if (peek_amount <= size)
				return peek_amount + receive((char*)buffer + peek_amount, size - peek_amount, receive_all);
		}

		return lowlevel_read(buffer, size, receive_all);
	}

	size_t ZipIODevice_FileEntry::peek(void *data, size_t len)
	{
		if (peeked_data.get_size() >= len)
		{
			memcpy(data, peeked_data.get_data(), len);
			return len;
		}
		else
		{
			size_t old_size = peeked_data.get_size();
			try
			{
				peeked_data.set_size(len);
				size_t bytes_read = lowlevel_read(peeked_data.get_data() + old_size, len - old_size, false);
				peeked_data.set_size(old_size + bytes_read);
				memcpy(data, peeked_data.get_data(), peeked_data.get_size());
				return peeked_data.get_size();
			}
			catch (const Exception& e)
			{
				peeked_data.set_size(old_size);
				throw;
			}
		}
	}

	bool ZipIODevice_FileEntry::seek(int seek_pos, IODevice::SeekMode mode)
	{
		int64_t absolute_pos = 0;
		switch (mode)
		{
		case IODevice::seek_set:
			absolute_pos = seek_pos;
			break;

		case IODevice::seek_cur:
			absolute_pos = pos + seek_pos;
			break;

		case IODevice::seek_end:
			absolute_pos = file_header.uncompressed_size + seek_pos;
			break;
		}

		switch (file_header.compression_method)
		{
		case zip_compress_store: // no compression
			iodevice.seek(int(absolute_pos - pos), IODevice::seek_cur);
			break;

		case zip_compress_deflate:
			// if backward seeking, restart at beginning of stream.
			if (absolute_pos < pos)
			{
				deinit();
				init();
			}

			char buffer[1024];
			while (absolute_pos > pos)
			{
				size_t received = receive(buffer, size_t(min(absolute_pos - pos, (int64_t)1024)), true);
				if (received == 0) break;
			}
			break;

		case zip_compress_shrunk:
		case zip_compress_expand_factor_1:
		case zip_compress_expand_factor_2:
		case zip_compress_expand_factor_3:
		case zip_compress_expand_factor_4:
		case zip_compress_implode:
		case zip_compress_tokenize:
		case zip_compress_deflate64:
		case zip_compress_pkware_implode:
			return false;
		}
		return true;
	}

	IODeviceProvider *ZipIODevice_FileEntry::duplicate()
	{
		ZipIODevice_FileEntry *new_provider = new ZipIODevice_FileEntry(this, file_entry);
		return new_provider;
	}

	void ZipIODevice_FileEntry::init()
	{
		iodevice.seek(file_entry.impl->record.relative_offset_of_local_header, IODevice::seek_set);
		file_header.load(iodevice);

		//This fix allows OS X created .zips to be opened - SAR
		if (file_header.general_purpose_bit_flag  & ZIP_CRC32_IN_FILE_DESCRIPTOR) //if this bit is set, it means the local header data for sizes was not
		{
			//the correct size data is not in the local header.. luckily, we have a real copy from the entry database
			file_header.compressed_size = file_entry.get_compressed_size();
			file_header.uncompressed_size = file_entry.get_uncompressed_size();
		}

		pos = 0;
		compressed_pos = 0;

		// Initialize decompression:
		int result = 0;
		switch (file_header.compression_method)
		{
		case zip_compress_store: // no compression
			break;

		case zip_compress_deflate:
			memset(&zs, 0, sizeof(mz_stream));
			zs.next_in = nullptr;
			zs.avail_in = 0;
			zs.zalloc = nullptr;
			zs.zfree = nullptr;
			zs.opaque = nullptr;
			//result = inflateInit(&zs);
			result = mz_inflateInit2(&zs, -15); // Undocumented: if wbits is negative, zlib skips header check
			if (result != MZ_OK) throw Exception("Zlib inflateInit failed for zip index!");
			zstream_open = true;
			break;

		case zip_compress_shrunk:
		case zip_compress_expand_factor_1:
		case zip_compress_expand_factor_2:
		case zip_compress_expand_factor_3:
		case zip_compress_expand_factor_4:
		case zip_compress_implode:
		case zip_compress_tokenize:
		case zip_compress_deflate64:
		case zip_compress_pkware_implode:
		default:
			throw Exception(string_format("Unsupported compression method %1", file_header.compression_method));
		}
	}

	void ZipIODevice_FileEntry::deinit()
	{
		// Clean up decompression:
		switch (file_header.compression_method)
		{
		case zip_compress_store: // no compression
			break;

		case zip_compress_deflate:
			if (zstream_open)
				mz_inflateEnd(&zs);
			zstream_open = false;
			break;

		case zip_compress_shrunk:
		case zip_compress_expand_factor_1:
		case zip_compress_expand_factor_2:
		case zip_compress_expand_factor_3:
		case zip_compress_expand_factor_4:
		case zip_compress_implode:
		case zip_compress_tokenize:
		case zip_compress_deflate64:
		case zip_compress_pkware_implode:
			break;
		}
	}

	size_t ZipIODevice_FileEntry::lowlevel_read(void *data, size_t size, bool read_all)
	{
		switch (file_header.compression_method)
		{
		case zip_compress_store: // no compression
		{
			size_t received = iodevice.receive(data, size_t(min((int64_t)size, file_header.uncompressed_size - pos)), read_all);
			pos += received;
			return received;
		}
		break;

		case zip_compress_deflate:
			zs.next_out = (unsigned char *)data;
			zs.avail_out = (unsigned int)size;
			// Continue feeding zlib data until we get our data:
			while (zs.avail_out > 0)
			{
				// zlib needs more data:
				if (zs.avail_in == 0 && compressed_pos < file_header.compressed_size)
				{
					// Read some compressed data:
					size_t received_input = 0;
					while (received_input < 16 * 1024)
					{
						received_input += iodevice.receive(zbuffer, size_t(min((int64_t)16 * 1024, file_header.compressed_size - compressed_pos)), true);
						if (compressed_pos + received_input == file_header.compressed_size) break;
					}
					compressed_pos += received_input;

					zs.next_in = (unsigned char *)zbuffer;
					zs.avail_in = (unsigned int)received_input;
				}

				// Decompress data:
				int result = mz_inflate(&zs, 0);
				if (result == MZ_STREAM_END) break;
				if (result == MZ_NEED_DICT) throw Exception("Zlib inflate wants a dictionary!");
				if (result == MZ_DATA_ERROR) throw Exception("Zip data stream is corrupted");
				if (result == MZ_STREAM_ERROR) throw Exception("Zip stream structure was inconsistent!");
				if (result == MZ_MEM_ERROR) throw Exception("Zlib did not have enough memory to decompress file!");
				if (result == MZ_BUF_ERROR) throw Exception("Not enough data in buffer when Z_FINISH was used");
				if (result != MZ_OK) throw Exception("Zlib inflate failed while decompressing zip file!");
			}
			pos += size - size_t(zs.avail_out);
			return size - size_t(zs.avail_out);

		case zip_compress_shrunk:
		case zip_compress_expand_factor_1:
		case zip_compress_expand_factor_2:
		case zip_compress_expand_factor_3:
		case zip_compress_expand_factor_4:
		case zip_compress_implode:
		case zip_compress_tokenize:
		case zip_compress_deflate64:
		case zip_compress_pkware_implode:
			break;
		}

		return 0;
	}
}

{'repo_name': 'sphair/ClanLib', 'stars': '265', 'repo_language': 'C++', 'file_name': 'Makefile', 'mime_type': 'text/x-makefile', 'hash': -1082694191789611918, 'source_dataset': 'data'}


<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN" "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">

<title>Luminance HDR User Manual — Tonemapping operators reference — Reinard'02</title>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<link href="style.css" rel="stylesheet" type="text/css" />

Reinhard'02

The implementation of the Reinhard tone mapping operator as described in:

Photographic Tone Reproduction for Digital Images.
E. Reinhard, M. Stark, P. Shirley, and J. Ferwerda.
In ACM Transactions on Graphics, 2002.

According to the paper, results of this TMO require gamma correction.

OPTIONS

Key Value

Set key value for the image (refer to paper for details).
Default value: 0.18, accepted range <0..1>.

Phi Value

Set phi value (refer to paper for details).
Default value: 1.0, accepted range >=0.0.

Use Scales

Use scales to calculate local adaptation. That means: use local
version of this operator. By default, global version is used.

Range

Set range size (refer to paper for details).
Default value: 8, accepted range >1.

Lower Scale

Set lower scale size (refer to paper for details).
Default value: 1, accepted range >=1.

Upper Scale

Set upper scale size (refer to paper for details).
Default value: 43, accepted range >=1.

{'repo_name': 'LuminanceHDR/LuminanceHDR', 'stars': '412', 'repo_language': 'C++', 'file_name': 'DefineCMakeDefaults.cmake', 'mime_type': 'text/plain', 'hash': 5244061081440826926, 'source_dataset': 'data'}


NUMBER_DICT = {str(key):value for key,value in enumerate(range(0,10))}

def selfInt(str1):
    number_list = str1.split('.')
    if len(number_list) > 2: # 4.3.2
        raise ValueError(f'{str1}不能转化为整数！！！')
    number_str = number_list[0]
    length = len(number_str)
    number = 0
    for key,value in enumerate(number_str):
        dict_value = NUMBER_DICT.get(value)
        if dict_value is None:
            raise ValueError(f'不能将{value}转化为整数！！！')
        else:
            number = number + dict_value * 10 ** (length - key - 1)
    return number

def selfFloat(str1):
    number_list = str1.split('.')
    if len(number_list) > 2:
        raise ValueError(f'{str1}z不能转化为整数！！！')

    int_number_str = number_list[0]
    if len(number_list) == 1:
        decimals_number_str = '0'
    else:
        decimals_number_str = number_list[1]
    int_length = len(int_number_str)
    number = 0
    for key,value in enumerate(int_number_str):
        dict_value = NUMBER_DICT.get(value)
        if dict_value is None:
            raise ValueError(f'不能将{value}转化为整数！！！')
        else:
            number = number + dict_value * 10 ** (int_length - key - 1)

    for key,value in enumerate(decimals_number_str):
        dict_value = NUMBER_DICT.get(value)
        if dict_value is None:
            raise ValueError(f'不能将{value}转化为小数！！！')
        else:
            number = number + dict_value * 10 ** (-1 - key)

    return number

if __name__ == '__main__':
    print(selfInt('101'))
    print(selfInt('11.2'))
    print(selfInt('101.2'))
    print(selfFloat('101.2'))
    print(selfFloat('10.2'))
    print(selfFloat('10'))

{'repo_name': 'MiracleYoung/You-are-Pythonista', 'stars': '521', 'repo_language': 'Python', 'file_name': 'image_classification.ipynb', 'mime_type': 'text/plain', 'hash': -4603620950564805734, 'source_dataset': 'data'}